diff --git a/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen.c b/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen.c deleted file mode 100644 index 0cad2bbde275a..0000000000000 --- a/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen.c +++ /dev/null @@ -1,267 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_adc_ctrl_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "adc_ctrl_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_init(mmio_region_t base_addr, - dif_adc_ctrl_t *adc_ctrl) { - if (adc_ctrl == NULL) { - return kDifBadArg; - } - - adc_ctrl->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_adc_ctrl_alert_force(const dif_adc_ctrl_t *adc_ctrl, - dif_adc_ctrl_alert_t alert) { - if (adc_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifAdcCtrlAlertFatalFault: - alert_idx = ADC_CTRL_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(adc_ctrl->base_addr, - (ptrdiff_t)ADC_CTRL_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool adc_ctrl_get_irq_bit_index(dif_adc_ctrl_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifAdcCtrlIrqMatchPending: - *index_out = ADC_CTRL_INTR_COMMON_MATCH_PENDING_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeStatus, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_get_type(const dif_adc_ctrl_t *adc_ctrl, - dif_adc_ctrl_irq_t irq, - dif_irq_type_t *type) { - if (adc_ctrl == NULL || type == NULL || irq < 0 || - irq > kDifAdcCtrlIrqMatchPending) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_get_state( - const dif_adc_ctrl_t *adc_ctrl, - dif_adc_ctrl_irq_state_snapshot_t *snapshot) { - if (adc_ctrl == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(adc_ctrl->base_addr, - (ptrdiff_t)ADC_CTRL_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, - (ptrdiff_t)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) { - if (adc_ctrl == NULL || is_pending == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!adc_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - adc_ctrl->base_addr, (ptrdiff_t)ADC_CTRL_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_acknowledge_all(const dif_adc_ctrl_t *adc_ctrl) { - if (adc_ctrl == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(adc_ctrl->base_addr, - (ptrdiff_t)ADC_CTRL_INTR_STATE_REG_OFFSET, UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_acknowledge(const dif_adc_ctrl_t *adc_ctrl, - dif_adc_ctrl_irq_t irq) { - if (adc_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!adc_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(adc_ctrl->base_addr, - (ptrdiff_t)ADC_CTRL_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_force(const dif_adc_ctrl_t *adc_ctrl, - dif_adc_ctrl_irq_t irq, const bool val) { - if (adc_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!adc_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(adc_ctrl->base_addr, - (ptrdiff_t)ADC_CTRL_INTR_TEST_REG_OFFSET, intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_get_enabled(const dif_adc_ctrl_t *adc_ctrl, - dif_adc_ctrl_irq_t irq, - dif_toggle_t *state) { - if (adc_ctrl == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!adc_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - adc_ctrl->base_addr, (ptrdiff_t)ADC_CTRL_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_set_enabled(const dif_adc_ctrl_t *adc_ctrl, - dif_adc_ctrl_irq_t irq, - dif_toggle_t state) { - if (adc_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!adc_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - adc_ctrl->base_addr, (ptrdiff_t)ADC_CTRL_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(adc_ctrl->base_addr, - (ptrdiff_t)ADC_CTRL_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_disable_all( - const dif_adc_ctrl_t *adc_ctrl, - dif_adc_ctrl_irq_enable_snapshot_t *snapshot) { - if (adc_ctrl == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(adc_ctrl->base_addr, - (ptrdiff_t)ADC_CTRL_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(adc_ctrl->base_addr, - (ptrdiff_t)ADC_CTRL_INTR_ENABLE_REG_OFFSET, 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_restore_all( - const dif_adc_ctrl_t *adc_ctrl, - const dif_adc_ctrl_irq_enable_snapshot_t *snapshot) { - if (adc_ctrl == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(adc_ctrl->base_addr, - (ptrdiff_t)ADC_CTRL_INTR_ENABLE_REG_OFFSET, *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen.h b/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen.h deleted file mode 100644 index 02e61b7134eee..0000000000000 --- a/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen.h +++ /dev/null @@ -1,243 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_ADC_CTRL_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_ADC_CTRL_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief ADC_CTRL Device Interface - * Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to adc_ctrl. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_adc_ctrl { - /** - * The base address for the adc_ctrl hardware registers. - */ - mmio_region_t base_addr; -} dif_adc_ctrl_t; - -/** - * Creates a new handle for a(n) adc_ctrl peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the adc_ctrl peripheral. - * @param[out] adc_ctrl Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_init(mmio_region_t base_addr, - dif_adc_ctrl_t *adc_ctrl); - -/** - * A adc_ctrl alert type. - */ -typedef enum dif_adc_ctrl_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifAdcCtrlAlertFatalFault = 0, -} dif_adc_ctrl_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param adc_ctrl A adc_ctrl handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_alert_force(const dif_adc_ctrl_t *adc_ctrl, - dif_adc_ctrl_alert_t alert); - -/** - * A adc_ctrl interrupt request type. - */ -typedef enum dif_adc_ctrl_irq { - /** - * ADC match or measurement event has occurred - */ - kDifAdcCtrlIrqMatchPending = 0, -} dif_adc_ctrl_irq_t; - -/** - * 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()` - * and `dif_adc_ctrl_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_adc_ctrl_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param adc_ctrl A adc_ctrl handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_get_type(const dif_adc_ctrl_t *adc_ctrl, - dif_adc_ctrl_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param adc_ctrl A adc_ctrl handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_get_state( - const dif_adc_ctrl_t *adc_ctrl, - dif_adc_ctrl_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param adc_ctrl A adc_ctrl handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param adc_ctrl A adc_ctrl handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_acknowledge_all(const dif_adc_ctrl_t *adc_ctrl); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param adc_ctrl A adc_ctrl handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_acknowledge(const dif_adc_ctrl_t *adc_ctrl, - dif_adc_ctrl_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param adc_ctrl A adc_ctrl handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_force(const dif_adc_ctrl_t *adc_ctrl, - dif_adc_ctrl_irq_t irq, const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_adc_ctrl_irq_disable_all()` and `dif_adc_ctrl_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_adc_ctrl_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param adc_ctrl A adc_ctrl handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_get_enabled(const dif_adc_ctrl_t *adc_ctrl, - dif_adc_ctrl_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param adc_ctrl A adc_ctrl handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_set_enabled(const dif_adc_ctrl_t *adc_ctrl, - dif_adc_ctrl_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param adc_ctrl A adc_ctrl handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_disable_all( - const dif_adc_ctrl_t *adc_ctrl, - dif_adc_ctrl_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param adc_ctrl A adc_ctrl handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_adc_ctrl_irq_restore_all( - const dif_adc_ctrl_t *adc_ctrl, - const dif_adc_ctrl_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_ADC_CTRL_AUTOGEN_H_ 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 deleted file mode 100644 index 60b8a9f8d95cd..0000000000000 --- a/sw/device/lib/dif/autogen/dif_adc_ctrl_autogen_unittest.cc +++ /dev/null @@ -1,359 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_adc_ctrl_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "adc_ctrl_regs.h" // Generated. - -namespace dif_adc_ctrl_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class AdcCtrlTest : public Test, public MmioTest { - protected: - dif_adc_ctrl_t adc_ctrl_ = {.base_addr = dev().region()}; -}; - -class InitTest : public AdcCtrlTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_adc_ctrl_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_adc_ctrl_init(dev().region(), &adc_ctrl_)); -} - -class AlertForceTest : public AdcCtrlTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_adc_ctrl_alert_force(nullptr, kDifAdcCtrlAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_adc_ctrl_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(ADC_CTRL_ALERT_TEST_REG_OFFSET, - {{ADC_CTRL_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK( - dif_adc_ctrl_alert_force(&adc_ctrl_, kDifAdcCtrlAlertFatalFault)); -} - -class IrqGetTypeTest : public AdcCtrlTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG( - dif_adc_ctrl_irq_get_type(nullptr, kDifAdcCtrlIrqMatchPending, &type)); - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_get_type( - &adc_ctrl_, kDifAdcCtrlIrqMatchPending, nullptr)); - - EXPECT_DIF_BADARG( - dif_adc_ctrl_irq_get_type(nullptr, kDifAdcCtrlIrqMatchPending, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_get_type( - &adc_ctrl_, - static_cast(kDifAdcCtrlIrqMatchPending + 1), &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK( - dif_adc_ctrl_irq_get_type(&adc_ctrl_, kDifAdcCtrlIrqMatchPending, &type)); - EXPECT_EQ(type, kDifIrqTypeStatus); -} - -class IrqGetStateTest : public AdcCtrlTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_adc_ctrl_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_get_state(&adc_ctrl_, nullptr)); - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_adc_ctrl_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(ADC_CTRL_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_adc_ctrl_irq_get_state(&adc_ctrl_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public AdcCtrlTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_is_pending( - nullptr, kDifAdcCtrlIrqMatchPending, &is_pending)); - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_is_pending( - &adc_ctrl_, kDifAdcCtrlIrqMatchPending, nullptr)); - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_is_pending( - nullptr, kDifAdcCtrlIrqMatchPending, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_is_pending( - &adc_ctrl_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(ADC_CTRL_INTR_STATE_REG_OFFSET, - {{ADC_CTRL_INTR_STATE_MATCH_PENDING_BIT, true}}); - EXPECT_DIF_OK(dif_adc_ctrl_irq_is_pending( - &adc_ctrl_, kDifAdcCtrlIrqMatchPending, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 1; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(ADC_CTRL_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_adc_ctrl_irq_acknowledge_all(&adc_ctrl_)); -} - -class IrqAcknowledgeTest : public AdcCtrlTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_adc_ctrl_irq_acknowledge(nullptr, kDifAdcCtrlIrqMatchPending)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_acknowledge( - nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(ADC_CTRL_INTR_STATE_REG_OFFSET, - {{ADC_CTRL_INTR_STATE_MATCH_PENDING_BIT, true}}); - EXPECT_DIF_OK( - dif_adc_ctrl_irq_acknowledge(&adc_ctrl_, kDifAdcCtrlIrqMatchPending)); -} - -class IrqForceTest : public AdcCtrlTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_adc_ctrl_irq_force(nullptr, kDifAdcCtrlIrqMatchPending, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_force( - nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(ADC_CTRL_INTR_TEST_REG_OFFSET, - {{ADC_CTRL_INTR_TEST_MATCH_PENDING_BIT, true}}); - EXPECT_DIF_OK( - dif_adc_ctrl_irq_force(&adc_ctrl_, kDifAdcCtrlIrqMatchPending, true)); -} - -class IrqGetEnabledTest : public AdcCtrlTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_get_enabled( - nullptr, kDifAdcCtrlIrqMatchPending, &irq_state)); - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_get_enabled( - &adc_ctrl_, kDifAdcCtrlIrqMatchPending, nullptr)); - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_get_enabled( - nullptr, kDifAdcCtrlIrqMatchPending, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_get_enabled( - &adc_ctrl_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(ADC_CTRL_INTR_ENABLE_REG_OFFSET, - {{ADC_CTRL_INTR_ENABLE_MATCH_PENDING_BIT, true}}); - EXPECT_DIF_OK(dif_adc_ctrl_irq_get_enabled( - &adc_ctrl_, kDifAdcCtrlIrqMatchPending, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); -} - -class IrqSetEnabledTest : public AdcCtrlTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_set_enabled( - nullptr, kDifAdcCtrlIrqMatchPending, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_set_enabled( - &adc_ctrl_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(ADC_CTRL_INTR_ENABLE_REG_OFFSET, - {{ADC_CTRL_INTR_ENABLE_MATCH_PENDING_BIT, 0x1, true}}); - EXPECT_DIF_OK(dif_adc_ctrl_irq_set_enabled( - &adc_ctrl_, kDifAdcCtrlIrqMatchPending, irq_state)); -} - -class IrqDisableAllTest : public AdcCtrlTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_adc_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(ADC_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_adc_ctrl_irq_disable_all(&adc_ctrl_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_adc_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(ADC_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(ADC_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_adc_ctrl_irq_disable_all(&adc_ctrl_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_adc_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(ADC_CTRL_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(ADC_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_adc_ctrl_irq_disable_all(&adc_ctrl_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public AdcCtrlTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_adc_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_restore_all(&adc_ctrl_, nullptr)); - - EXPECT_DIF_BADARG(dif_adc_ctrl_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_adc_ctrl_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(ADC_CTRL_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_adc_ctrl_irq_restore_all(&adc_ctrl_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_adc_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(ADC_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_adc_ctrl_irq_restore_all(&adc_ctrl_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_adc_ctrl_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_aes_autogen.c b/sw/device/lib/dif/autogen/dif_aes_autogen.c deleted file mode 100644 index 300e9a740831f..0000000000000 --- a/sw/device/lib/dif/autogen/dif_aes_autogen.c +++ /dev/null @@ -1,49 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_aes_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "aes_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_aes_init(mmio_region_t base_addr, dif_aes_t *aes) { - if (aes == NULL) { - return kDifBadArg; - } - - aes->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_aes_alert_force(const dif_aes_t *aes, dif_aes_alert_t alert) { - if (aes == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifAesAlertRecovCtrlUpdateErr: - alert_idx = AES_ALERT_TEST_RECOV_CTRL_UPDATE_ERR_BIT; - break; - case kDifAesAlertFatalFault: - alert_idx = AES_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(aes->base_addr, (ptrdiff_t)AES_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_aes_autogen.h b/sw/device/lib/dif/autogen/dif_aes_autogen.h deleted file mode 100644 index 936708f7217e2..0000000000000 --- a/sw/device/lib/dif/autogen/dif_aes_autogen.h +++ /dev/null @@ -1,90 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_AES_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_AES_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief AES Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to aes. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_aes { - /** - * The base address for the aes hardware registers. - */ - mmio_region_t base_addr; -} dif_aes_t; - -/** - * Creates a new handle for a(n) aes peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the aes peripheral. - * @param[out] aes Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_aes_init(mmio_region_t base_addr, dif_aes_t *aes); - -/** - * A aes alert type. - */ -typedef enum dif_aes_alert { - /** - * This recoverable alert is triggered upon detecting an update error in the - * shadowed Control Register. The content of the Control Register is not - * modified (See Control Register). The AES unit can be recovered from such a - * condition by restarting the AES operation, i.e., by re-writing the Control - * Register. This should be monitored by the system. - */ - kDifAesAlertRecovCtrlUpdateErr = 0, - /** - * This fatal alert is triggered upon detecting a fatal fault inside the AES - * unit. Examples for such faults include i) storage errors in the shadowed - * Control Register, ii) any internal FSM entering an invalid state, iii) any - * sparsely encoded signal taking on an invalid value, iv) errors in the - * internal round counter, v) escalations triggered by the life cycle - * controller, and vi) fatal integrity failures on the TL-UL bus. The AES unit - * cannot recover from such an error and needs to be reset. - */ - kDifAesAlertFatalFault = 1, -} dif_aes_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param aes A aes handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_aes_alert_force(const dif_aes_t *aes, dif_aes_alert_t alert); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_AES_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_aes_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_aes_autogen_unittest.cc deleted file mode 100644 index 22e2d0b7841a5..0000000000000 --- a/sw/device/lib/dif/autogen/dif_aes_autogen_unittest.cc +++ /dev/null @@ -1,64 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_aes_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "aes_regs.h" // Generated. - -namespace dif_aes_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class AesTest : public Test, public MmioTest { - protected: - dif_aes_t aes_ = {.base_addr = dev().region()}; -}; - -class InitTest : public AesTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_aes_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_aes_init(dev().region(), &aes_)); -} - -class AlertForceTest : public AesTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_aes_alert_force(nullptr, kDifAesAlertRecovCtrlUpdateErr)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_aes_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(AES_ALERT_TEST_REG_OFFSET, - {{AES_ALERT_TEST_RECOV_CTRL_UPDATE_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_aes_alert_force(&aes_, kDifAesAlertRecovCtrlUpdateErr)); - - // Force last alert. - EXPECT_WRITE32(AES_ALERT_TEST_REG_OFFSET, - {{AES_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_aes_alert_force(&aes_, kDifAesAlertFatalFault)); -} - -} // namespace -} // namespace dif_aes_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_alert_handler_autogen.c b/sw/device/lib/dif/autogen/dif_alert_handler_autogen.c deleted file mode 100644 index a91715acc746b..0000000000000 --- a/sw/device/lib/dif/autogen/dif_alert_handler_autogen.c +++ /dev/null @@ -1,264 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_alert_handler_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "alert_handler_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_init(mmio_region_t base_addr, - dif_alert_handler_t *alert_handler) { - if (alert_handler == NULL) { - return kDifBadArg; - } - - alert_handler->base_addr = base_addr; - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool alert_handler_get_irq_bit_index(dif_alert_handler_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifAlertHandlerIrqClassa: - *index_out = ALERT_HANDLER_INTR_COMMON_CLASSA_BIT; - break; - case kDifAlertHandlerIrqClassb: - *index_out = ALERT_HANDLER_INTR_COMMON_CLASSB_BIT; - break; - case kDifAlertHandlerIrqClassc: - *index_out = ALERT_HANDLER_INTR_COMMON_CLASSC_BIT; - break; - case kDifAlertHandlerIrqClassd: - *index_out = ALERT_HANDLER_INTR_COMMON_CLASSD_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, - kDifIrqTypeEvent, - kDifIrqTypeEvent, - kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_get_type( - const dif_alert_handler_t *alert_handler, dif_alert_handler_irq_t irq, - dif_irq_type_t *type) { - if (alert_handler == NULL || type == NULL || irq < 0 || - irq > kDifAlertHandlerIrqClassd) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_get_state( - const dif_alert_handler_t *alert_handler, - dif_alert_handler_irq_state_snapshot_t *snapshot) { - if (alert_handler == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32( - alert_handler->base_addr, (ptrdiff_t)ALERT_HANDLER_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, - (ptrdiff_t)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) { - if (alert_handler == NULL || is_pending == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!alert_handler_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - alert_handler->base_addr, (ptrdiff_t)ALERT_HANDLER_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_acknowledge_all( - const dif_alert_handler_t *alert_handler) { - if (alert_handler == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(alert_handler->base_addr, - (ptrdiff_t)ALERT_HANDLER_INTR_STATE_REG_OFFSET, - UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_acknowledge( - const dif_alert_handler_t *alert_handler, dif_alert_handler_irq_t irq) { - if (alert_handler == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!alert_handler_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(alert_handler->base_addr, - (ptrdiff_t)ALERT_HANDLER_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_force( - const dif_alert_handler_t *alert_handler, dif_alert_handler_irq_t irq, - const bool val) { - if (alert_handler == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!alert_handler_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(alert_handler->base_addr, - (ptrdiff_t)ALERT_HANDLER_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_get_enabled( - const dif_alert_handler_t *alert_handler, dif_alert_handler_irq_t irq, - dif_toggle_t *state) { - if (alert_handler == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!alert_handler_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = - mmio_region_read32(alert_handler->base_addr, - (ptrdiff_t)ALERT_HANDLER_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_set_enabled( - const dif_alert_handler_t *alert_handler, dif_alert_handler_irq_t irq, - dif_toggle_t state) { - if (alert_handler == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!alert_handler_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = - mmio_region_read32(alert_handler->base_addr, - (ptrdiff_t)ALERT_HANDLER_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(alert_handler->base_addr, - (ptrdiff_t)ALERT_HANDLER_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_disable_all( - const dif_alert_handler_t *alert_handler, - dif_alert_handler_irq_enable_snapshot_t *snapshot) { - if (alert_handler == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = - mmio_region_read32(alert_handler->base_addr, - (ptrdiff_t)ALERT_HANDLER_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(alert_handler->base_addr, - (ptrdiff_t)ALERT_HANDLER_INTR_ENABLE_REG_OFFSET, 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_restore_all( - const dif_alert_handler_t *alert_handler, - const dif_alert_handler_irq_enable_snapshot_t *snapshot) { - if (alert_handler == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(alert_handler->base_addr, - (ptrdiff_t)ALERT_HANDLER_INTR_ENABLE_REG_OFFSET, - *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_alert_handler_autogen.h b/sw/device/lib/dif/autogen/dif_alert_handler_autogen.h deleted file mode 100644 index 2792e48bc9a38..0000000000000 --- a/sw/device/lib/dif/autogen/dif_alert_handler_autogen.h +++ /dev/null @@ -1,240 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_ALERT_HANDLER_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_ALERT_HANDLER_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief ALERT_HANDLER Device - * Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to alert_handler. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_alert_handler { - /** - * The base address for the alert_handler hardware registers. - */ - mmio_region_t base_addr; -} dif_alert_handler_t; - -/** - * Creates a new handle for a(n) alert_handler peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the alert_handler peripheral. - * @param[out] alert_handler Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_init(mmio_region_t base_addr, - dif_alert_handler_t *alert_handler); - -/** - * A alert_handler interrupt request type. - */ -typedef enum dif_alert_handler_irq { - /** - * Interrupt state bit of Class A. Set by HW in case an alert within this - * class triggered. Defaults true, write one to clear. - */ - kDifAlertHandlerIrqClassa = 0, - /** - * Interrupt state bit of Class B. Set by HW in case an alert within this - * class triggered. Defaults true, write one to clear. - */ - kDifAlertHandlerIrqClassb = 1, - /** - * Interrupt state bit of Class C. Set by HW in case an alert within this - * class triggered. Defaults true, write one to clear. - */ - kDifAlertHandlerIrqClassc = 2, - /** - * Interrupt state bit of Class D. Set by HW in case an alert within this - * class triggered. Defaults true, write one to clear. - */ - kDifAlertHandlerIrqClassd = 3, -} dif_alert_handler_irq_t; - -/** - * 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()` and - * `dif_alert_handler_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_alert_handler_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param alert_handler A alert_handler handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_get_type( - const dif_alert_handler_t *alert_handler, dif_alert_handler_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param alert_handler A alert_handler handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_get_state( - const dif_alert_handler_t *alert_handler, - dif_alert_handler_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param alert_handler A alert_handler handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param alert_handler A alert_handler handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_acknowledge_all( - const dif_alert_handler_t *alert_handler); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param alert_handler A alert_handler handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_acknowledge( - const dif_alert_handler_t *alert_handler, dif_alert_handler_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param alert_handler A alert_handler handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_force( - const dif_alert_handler_t *alert_handler, dif_alert_handler_irq_t irq, - const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_alert_handler_irq_disable_all()` and - * `dif_alert_handler_irq_restore_all()` functions. - */ -typedef uint32_t dif_alert_handler_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param alert_handler A alert_handler handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_get_enabled( - const dif_alert_handler_t *alert_handler, dif_alert_handler_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param alert_handler A alert_handler handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_set_enabled( - const dif_alert_handler_t *alert_handler, dif_alert_handler_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param alert_handler A alert_handler handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_disable_all( - const dif_alert_handler_t *alert_handler, - dif_alert_handler_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param alert_handler A alert_handler handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_alert_handler_irq_restore_all( - const dif_alert_handler_t *alert_handler, - const dif_alert_handler_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_ALERT_HANDLER_AUTOGEN_H_ 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 deleted file mode 100644 index 816a556e0925b..0000000000000 --- a/sw/device/lib/dif/autogen/dif_alert_handler_autogen_unittest.cc +++ /dev/null @@ -1,385 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_alert_handler_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "alert_handler_regs.h" // Generated. - -namespace dif_alert_handler_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class AlertHandlerTest : public Test, public MmioTest { - protected: - dif_alert_handler_t alert_handler_ = {.base_addr = dev().region()}; -}; - -class InitTest : public AlertHandlerTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_alert_handler_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_alert_handler_init(dev().region(), &alert_handler_)); -} - -class IrqGetTypeTest : public AlertHandlerTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_alert_handler_irq_get_type( - nullptr, kDifAlertHandlerIrqClassa, &type)); - - EXPECT_DIF_BADARG(dif_alert_handler_irq_get_type( - &alert_handler_, kDifAlertHandlerIrqClassa, nullptr)); - - EXPECT_DIF_BADARG(dif_alert_handler_irq_get_type( - nullptr, kDifAlertHandlerIrqClassa, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_alert_handler_irq_get_type( - &alert_handler_, - static_cast(kDifAlertHandlerIrqClassd + 1), - &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_alert_handler_irq_get_type( - &alert_handler_, kDifAlertHandlerIrqClassa, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public AlertHandlerTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_alert_handler_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_alert_handler_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_alert_handler_irq_get_state(&alert_handler_, nullptr)); - - EXPECT_DIF_BADARG(dif_alert_handler_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_alert_handler_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(ALERT_HANDLER_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK( - dif_alert_handler_irq_get_state(&alert_handler_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public AlertHandlerTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG(dif_alert_handler_irq_is_pending( - nullptr, kDifAlertHandlerIrqClassa, &is_pending)); - - EXPECT_DIF_BADARG(dif_alert_handler_irq_is_pending( - &alert_handler_, kDifAlertHandlerIrqClassa, nullptr)); - - EXPECT_DIF_BADARG(dif_alert_handler_irq_is_pending( - nullptr, kDifAlertHandlerIrqClassa, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_alert_handler_irq_is_pending( - &alert_handler_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(ALERT_HANDLER_INTR_STATE_REG_OFFSET, - {{ALERT_HANDLER_INTR_STATE_CLASSA_BIT, true}}); - EXPECT_DIF_OK(dif_alert_handler_irq_is_pending( - &alert_handler_, kDifAlertHandlerIrqClassa, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(ALERT_HANDLER_INTR_STATE_REG_OFFSET, - {{ALERT_HANDLER_INTR_STATE_CLASSD_BIT, false}}); - EXPECT_DIF_OK(dif_alert_handler_irq_is_pending( - &alert_handler_, kDifAlertHandlerIrqClassd, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 4; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_alert_handler_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(ALERT_HANDLER_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_alert_handler_irq_acknowledge_all(&alert_handler_)); -} - -class IrqAcknowledgeTest : public AlertHandlerTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_alert_handler_irq_acknowledge(nullptr, kDifAlertHandlerIrqClassa)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG(dif_alert_handler_irq_acknowledge( - nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(ALERT_HANDLER_INTR_STATE_REG_OFFSET, - {{ALERT_HANDLER_INTR_STATE_CLASSA_BIT, true}}); - EXPECT_DIF_OK(dif_alert_handler_irq_acknowledge(&alert_handler_, - kDifAlertHandlerIrqClassa)); - - // Clear the last IRQ state. - EXPECT_WRITE32(ALERT_HANDLER_INTR_STATE_REG_OFFSET, - {{ALERT_HANDLER_INTR_STATE_CLASSD_BIT, true}}); - EXPECT_DIF_OK(dif_alert_handler_irq_acknowledge(&alert_handler_, - kDifAlertHandlerIrqClassd)); -} - -class IrqForceTest : public AlertHandlerTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_alert_handler_irq_force(nullptr, kDifAlertHandlerIrqClassa, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG(dif_alert_handler_irq_force( - nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(ALERT_HANDLER_INTR_TEST_REG_OFFSET, - {{ALERT_HANDLER_INTR_TEST_CLASSA_BIT, true}}); - EXPECT_DIF_OK(dif_alert_handler_irq_force(&alert_handler_, - kDifAlertHandlerIrqClassa, true)); - - // Force last IRQ. - EXPECT_WRITE32(ALERT_HANDLER_INTR_TEST_REG_OFFSET, - {{ALERT_HANDLER_INTR_TEST_CLASSD_BIT, true}}); - EXPECT_DIF_OK(dif_alert_handler_irq_force(&alert_handler_, - kDifAlertHandlerIrqClassd, true)); -} - -class IrqGetEnabledTest : public AlertHandlerTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_alert_handler_irq_get_enabled( - nullptr, kDifAlertHandlerIrqClassa, &irq_state)); - - EXPECT_DIF_BADARG(dif_alert_handler_irq_get_enabled( - &alert_handler_, kDifAlertHandlerIrqClassa, nullptr)); - - EXPECT_DIF_BADARG(dif_alert_handler_irq_get_enabled( - nullptr, kDifAlertHandlerIrqClassa, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_alert_handler_irq_get_enabled( - &alert_handler_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(ALERT_HANDLER_INTR_ENABLE_REG_OFFSET, - {{ALERT_HANDLER_INTR_ENABLE_CLASSA_BIT, true}}); - EXPECT_DIF_OK(dif_alert_handler_irq_get_enabled( - &alert_handler_, kDifAlertHandlerIrqClassa, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(ALERT_HANDLER_INTR_ENABLE_REG_OFFSET, - {{ALERT_HANDLER_INTR_ENABLE_CLASSD_BIT, false}}); - EXPECT_DIF_OK(dif_alert_handler_irq_get_enabled( - &alert_handler_, kDifAlertHandlerIrqClassd, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public AlertHandlerTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_alert_handler_irq_set_enabled( - nullptr, kDifAlertHandlerIrqClassa, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_alert_handler_irq_set_enabled( - &alert_handler_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(ALERT_HANDLER_INTR_ENABLE_REG_OFFSET, - {{ALERT_HANDLER_INTR_ENABLE_CLASSA_BIT, 0x1, true}}); - EXPECT_DIF_OK(dif_alert_handler_irq_set_enabled( - &alert_handler_, kDifAlertHandlerIrqClassa, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(ALERT_HANDLER_INTR_ENABLE_REG_OFFSET, - {{ALERT_HANDLER_INTR_ENABLE_CLASSD_BIT, 0x1, false}}); - EXPECT_DIF_OK(dif_alert_handler_irq_set_enabled( - &alert_handler_, kDifAlertHandlerIrqClassd, irq_state)); -} - -class IrqDisableAllTest : public AlertHandlerTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_alert_handler_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_alert_handler_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_alert_handler_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(ALERT_HANDLER_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_alert_handler_irq_disable_all(&alert_handler_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_alert_handler_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(ALERT_HANDLER_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(ALERT_HANDLER_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK( - dif_alert_handler_irq_disable_all(&alert_handler_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_alert_handler_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(ALERT_HANDLER_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(ALERT_HANDLER_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK( - dif_alert_handler_irq_disable_all(&alert_handler_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public AlertHandlerTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_alert_handler_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_alert_handler_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG( - dif_alert_handler_irq_restore_all(&alert_handler_, nullptr)); - - EXPECT_DIF_BADARG(dif_alert_handler_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_alert_handler_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(ALERT_HANDLER_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK( - dif_alert_handler_irq_restore_all(&alert_handler_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_alert_handler_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(ALERT_HANDLER_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK( - dif_alert_handler_irq_restore_all(&alert_handler_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_alert_handler_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_aon_timer_autogen.c b/sw/device/lib/dif/autogen/dif_aon_timer_autogen.c deleted file mode 100644 index 1af5bbe5b038a..0000000000000 --- a/sw/device/lib/dif/autogen/dif_aon_timer_autogen.c +++ /dev/null @@ -1,198 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_aon_timer_autogen.h" - -#include -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "aon_timer_regs.h" // Generated. - -static_assert(AON_TIMER_INTR_STATE_WKUP_TIMER_EXPIRED_BIT == - AON_TIMER_INTR_TEST_WKUP_TIMER_EXPIRED_BIT, - "Expected IRQ bit offsets to match across STATE/TEST regs."); -static_assert(AON_TIMER_INTR_STATE_WDOG_TIMER_BARK_BIT == - AON_TIMER_INTR_TEST_WDOG_TIMER_BARK_BIT, - "Expected IRQ bit offsets to match across STATE/TEST regs."); - -OT_WARN_UNUSED_RESULT -dif_result_t dif_aon_timer_init(mmio_region_t base_addr, - dif_aon_timer_t *aon_timer) { - if (aon_timer == NULL) { - return kDifBadArg; - } - - aon_timer->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_aon_timer_alert_force(const dif_aon_timer_t *aon_timer, - dif_aon_timer_alert_t alert) { - if (aon_timer == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifAonTimerAlertFatalFault: - alert_idx = AON_TIMER_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(aon_timer->base_addr, - (ptrdiff_t)AON_TIMER_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool aon_timer_get_irq_bit_index(dif_aon_timer_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifAonTimerIrqWkupTimerExpired: - *index_out = AON_TIMER_INTR_STATE_WKUP_TIMER_EXPIRED_BIT; - break; - case kDifAonTimerIrqWdogTimerBark: - *index_out = AON_TIMER_INTR_STATE_WDOG_TIMER_BARK_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, - kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_aon_timer_irq_get_type(const dif_aon_timer_t *aon_timer, - dif_aon_timer_irq_t irq, - dif_irq_type_t *type) { - if (aon_timer == NULL || type == NULL || irq < 0 || - irq > kDifAonTimerIrqWdogTimerBark) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_aon_timer_irq_get_state( - const dif_aon_timer_t *aon_timer, - dif_aon_timer_irq_state_snapshot_t *snapshot) { - if (aon_timer == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(aon_timer->base_addr, - (ptrdiff_t)AON_TIMER_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, - (ptrdiff_t)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) { - if (aon_timer == NULL || is_pending == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!aon_timer_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - aon_timer->base_addr, (ptrdiff_t)AON_TIMER_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_aon_timer_irq_acknowledge_all( - const dif_aon_timer_t *aon_timer) { - if (aon_timer == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(aon_timer->base_addr, - (ptrdiff_t)AON_TIMER_INTR_STATE_REG_OFFSET, UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_aon_timer_irq_acknowledge(const dif_aon_timer_t *aon_timer, - dif_aon_timer_irq_t irq) { - if (aon_timer == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!aon_timer_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(aon_timer->base_addr, - (ptrdiff_t)AON_TIMER_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_aon_timer_irq_force(const dif_aon_timer_t *aon_timer, - dif_aon_timer_irq_t irq, const bool val) { - if (aon_timer == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!aon_timer_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(aon_timer->base_addr, - (ptrdiff_t)AON_TIMER_INTR_TEST_REG_OFFSET, intr_test_reg); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_aon_timer_autogen.h b/sw/device/lib/dif/autogen/dif_aon_timer_autogen.h deleted file mode 100644 index 060b519c833a5..0000000000000 --- a/sw/device/lib/dif/autogen/dif_aon_timer_autogen.h +++ /dev/null @@ -1,189 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_AON_TIMER_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_AON_TIMER_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief AON_TIMER Device Interface - * Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to aon_timer. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_aon_timer { - /** - * The base address for the aon_timer hardware registers. - */ - mmio_region_t base_addr; -} dif_aon_timer_t; - -/** - * Creates a new handle for a(n) aon_timer peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the aon_timer peripheral. - * @param[out] aon_timer Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_aon_timer_init(mmio_region_t base_addr, - dif_aon_timer_t *aon_timer); - -/** - * A aon_timer alert type. - */ -typedef enum dif_aon_timer_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifAonTimerAlertFatalFault = 0, -} dif_aon_timer_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param aon_timer A aon_timer handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_aon_timer_alert_force(const dif_aon_timer_t *aon_timer, - dif_aon_timer_alert_t alert); - -/** - * A aon_timer interrupt request type. - */ -typedef enum dif_aon_timer_irq { - /** - * Raised if the wakeup timer has hit the specified threshold - */ - kDifAonTimerIrqWkupTimerExpired = 0, - /** - * Raised if the watchdog timer has hit the bark threshold - */ - kDifAonTimerIrqWdogTimerBark = 1, -} dif_aon_timer_irq_t; - -/** - * 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()` - * and `dif_aon_timer_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_aon_timer_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param aon_timer A aon_timer handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_aon_timer_irq_get_type(const dif_aon_timer_t *aon_timer, - dif_aon_timer_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param aon_timer A aon_timer handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_aon_timer_irq_get_state( - const dif_aon_timer_t *aon_timer, - dif_aon_timer_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param aon_timer A aon_timer handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param aon_timer A aon_timer handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_aon_timer_irq_acknowledge_all( - const dif_aon_timer_t *aon_timer); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param aon_timer A aon_timer handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_aon_timer_irq_acknowledge(const dif_aon_timer_t *aon_timer, - dif_aon_timer_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param aon_timer A aon_timer handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_aon_timer_irq_force(const dif_aon_timer_t *aon_timer, - dif_aon_timer_irq_t irq, const bool val); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_AON_TIMER_AUTOGEN_H_ 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 deleted file mode 100644 index b85d6b836b90a..0000000000000 --- a/sw/device/lib/dif/autogen/dif_aon_timer_autogen_unittest.cc +++ /dev/null @@ -1,258 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_aon_timer_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "aon_timer_regs.h" // Generated. - -namespace dif_aon_timer_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class AonTimerTest : public Test, public MmioTest { - protected: - dif_aon_timer_t aon_timer_ = {.base_addr = dev().region()}; -}; - -class InitTest : public AonTimerTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_aon_timer_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_aon_timer_init(dev().region(), &aon_timer_)); -} - -class AlertForceTest : public AonTimerTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_aon_timer_alert_force(nullptr, kDifAonTimerAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG(dif_aon_timer_alert_force( - nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(AON_TIMER_ALERT_TEST_REG_OFFSET, - {{AON_TIMER_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK( - dif_aon_timer_alert_force(&aon_timer_, kDifAonTimerAlertFatalFault)); -} - -class IrqGetTypeTest : public AonTimerTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_aon_timer_irq_get_type( - nullptr, kDifAonTimerIrqWkupTimerExpired, &type)); - - EXPECT_DIF_BADARG(dif_aon_timer_irq_get_type( - &aon_timer_, kDifAonTimerIrqWkupTimerExpired, nullptr)); - - EXPECT_DIF_BADARG(dif_aon_timer_irq_get_type( - nullptr, kDifAonTimerIrqWkupTimerExpired, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_aon_timer_irq_get_type( - &aon_timer_, - static_cast(kDifAonTimerIrqWdogTimerBark + 1), - &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_aon_timer_irq_get_type( - &aon_timer_, kDifAonTimerIrqWkupTimerExpired, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public AonTimerTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_aon_timer_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_aon_timer_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_aon_timer_irq_get_state(&aon_timer_, nullptr)); - - EXPECT_DIF_BADARG(dif_aon_timer_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_aon_timer_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(AON_TIMER_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_aon_timer_irq_get_state(&aon_timer_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public AonTimerTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG(dif_aon_timer_irq_is_pending( - nullptr, kDifAonTimerIrqWkupTimerExpired, &is_pending)); - - EXPECT_DIF_BADARG(dif_aon_timer_irq_is_pending( - &aon_timer_, kDifAonTimerIrqWkupTimerExpired, nullptr)); - - EXPECT_DIF_BADARG(dif_aon_timer_irq_is_pending( - nullptr, kDifAonTimerIrqWkupTimerExpired, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_aon_timer_irq_is_pending( - &aon_timer_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(AON_TIMER_INTR_STATE_REG_OFFSET, - {{AON_TIMER_INTR_STATE_WKUP_TIMER_EXPIRED_BIT, true}}); - EXPECT_DIF_OK(dif_aon_timer_irq_is_pending( - &aon_timer_, kDifAonTimerIrqWkupTimerExpired, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(AON_TIMER_INTR_STATE_REG_OFFSET, - {{AON_TIMER_INTR_STATE_WDOG_TIMER_BARK_BIT, false}}); - EXPECT_DIF_OK(dif_aon_timer_irq_is_pending( - &aon_timer_, kDifAonTimerIrqWdogTimerBark, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 2; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_aon_timer_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(AON_TIMER_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_aon_timer_irq_acknowledge_all(&aon_timer_)); -} - -class IrqAcknowledgeTest : public AonTimerTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_aon_timer_irq_acknowledge(nullptr, kDifAonTimerIrqWkupTimerExpired)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG(dif_aon_timer_irq_acknowledge( - nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(AON_TIMER_INTR_STATE_REG_OFFSET, - {{AON_TIMER_INTR_STATE_WKUP_TIMER_EXPIRED_BIT, true}}); - EXPECT_DIF_OK(dif_aon_timer_irq_acknowledge(&aon_timer_, - kDifAonTimerIrqWkupTimerExpired)); - - // Clear the last IRQ state. - EXPECT_WRITE32(AON_TIMER_INTR_STATE_REG_OFFSET, - {{AON_TIMER_INTR_STATE_WDOG_TIMER_BARK_BIT, true}}); - EXPECT_DIF_OK( - dif_aon_timer_irq_acknowledge(&aon_timer_, kDifAonTimerIrqWdogTimerBark)); -} - -class IrqForceTest : public AonTimerTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_aon_timer_irq_force(nullptr, kDifAonTimerIrqWkupTimerExpired, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG(dif_aon_timer_irq_force( - nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(AON_TIMER_INTR_TEST_REG_OFFSET, - {{AON_TIMER_INTR_TEST_WKUP_TIMER_EXPIRED_BIT, true}}); - EXPECT_DIF_OK(dif_aon_timer_irq_force(&aon_timer_, - kDifAonTimerIrqWkupTimerExpired, true)); - - // Force last IRQ. - EXPECT_WRITE32(AON_TIMER_INTR_TEST_REG_OFFSET, - {{AON_TIMER_INTR_TEST_WDOG_TIMER_BARK_BIT, true}}); - EXPECT_DIF_OK( - dif_aon_timer_irq_force(&aon_timer_, kDifAonTimerIrqWdogTimerBark, true)); -} - -} // namespace -} // namespace dif_aon_timer_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_clkmgr_autogen.c b/sw/device/lib/dif/autogen/dif_clkmgr_autogen.c deleted file mode 100644 index d51500361152e..0000000000000 --- a/sw/device/lib/dif/autogen/dif_clkmgr_autogen.c +++ /dev/null @@ -1,50 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_clkmgr_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "clkmgr_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_clkmgr_init(mmio_region_t base_addr, dif_clkmgr_t *clkmgr) { - if (clkmgr == NULL) { - return kDifBadArg; - } - - clkmgr->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_clkmgr_alert_force(const dif_clkmgr_t *clkmgr, - dif_clkmgr_alert_t alert) { - if (clkmgr == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifClkmgrAlertRecovFault: - alert_idx = CLKMGR_ALERT_TEST_RECOV_FAULT_BIT; - break; - case kDifClkmgrAlertFatalFault: - alert_idx = CLKMGR_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(clkmgr->base_addr, - (ptrdiff_t)CLKMGR_ALERT_TEST_REG_OFFSET, alert_test_reg); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_clkmgr_autogen.h b/sw/device/lib/dif/autogen/dif_clkmgr_autogen.h deleted file mode 100644 index 88605d6d6b4e0..0000000000000 --- a/sw/device/lib/dif/autogen/dif_clkmgr_autogen.h +++ /dev/null @@ -1,82 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_CLKMGR_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_CLKMGR_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief CLKMGR Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to clkmgr. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_clkmgr { - /** - * The base address for the clkmgr hardware registers. - */ - mmio_region_t base_addr; -} dif_clkmgr_t; - -/** - * Creates a new handle for a(n) clkmgr peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the clkmgr peripheral. - * @param[out] clkmgr Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_clkmgr_init(mmio_region_t base_addr, dif_clkmgr_t *clkmgr); - -/** - * A clkmgr alert type. - */ -typedef enum dif_clkmgr_alert { - /** - * This recoverable alert is triggered when there are measurement errors. - */ - kDifClkmgrAlertRecovFault = 0, - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifClkmgrAlertFatalFault = 1, -} dif_clkmgr_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param clkmgr A clkmgr handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_clkmgr_alert_force(const dif_clkmgr_t *clkmgr, - dif_clkmgr_alert_t alert); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_CLKMGR_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_clkmgr_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_clkmgr_autogen_unittest.cc deleted file mode 100644 index 8c84b5ead40c7..0000000000000 --- a/sw/device/lib/dif/autogen/dif_clkmgr_autogen_unittest.cc +++ /dev/null @@ -1,63 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_clkmgr_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "clkmgr_regs.h" // Generated. - -namespace dif_clkmgr_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class ClkmgrTest : public Test, public MmioTest { - protected: - dif_clkmgr_t clkmgr_ = {.base_addr = dev().region()}; -}; - -class InitTest : public ClkmgrTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_clkmgr_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_clkmgr_init(dev().region(), &clkmgr_)); -} - -class AlertForceTest : public ClkmgrTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_clkmgr_alert_force(nullptr, kDifClkmgrAlertRecovFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_clkmgr_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(CLKMGR_ALERT_TEST_REG_OFFSET, - {{CLKMGR_ALERT_TEST_RECOV_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_clkmgr_alert_force(&clkmgr_, kDifClkmgrAlertRecovFault)); - - // Force last alert. - EXPECT_WRITE32(CLKMGR_ALERT_TEST_REG_OFFSET, - {{CLKMGR_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_clkmgr_alert_force(&clkmgr_, kDifClkmgrAlertFatalFault)); -} - -} // namespace -} // namespace dif_clkmgr_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_csrng_autogen.c b/sw/device/lib/dif/autogen/dif_csrng_autogen.c deleted file mode 100644 index d1d9552ff621e..0000000000000 --- a/sw/device/lib/dif/autogen/dif_csrng_autogen.c +++ /dev/null @@ -1,272 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_csrng_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "csrng_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_init(mmio_region_t base_addr, dif_csrng_t *csrng) { - if (csrng == NULL) { - return kDifBadArg; - } - - csrng->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_csrng_alert_force(const dif_csrng_t *csrng, - dif_csrng_alert_t alert) { - if (csrng == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifCsrngAlertRecovAlert: - alert_idx = CSRNG_ALERT_TEST_RECOV_ALERT_BIT; - break; - case kDifCsrngAlertFatalAlert: - alert_idx = CSRNG_ALERT_TEST_FATAL_ALERT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(csrng->base_addr, (ptrdiff_t)CSRNG_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool csrng_get_irq_bit_index(dif_csrng_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifCsrngIrqCsCmdReqDone: - *index_out = CSRNG_INTR_COMMON_CS_CMD_REQ_DONE_BIT; - break; - case kDifCsrngIrqCsEntropyReq: - *index_out = CSRNG_INTR_COMMON_CS_ENTROPY_REQ_BIT; - break; - case kDifCsrngIrqCsHwInstExc: - *index_out = CSRNG_INTR_COMMON_CS_HW_INST_EXC_BIT; - break; - case kDifCsrngIrqCsFatalErr: - *index_out = CSRNG_INTR_COMMON_CS_FATAL_ERR_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, - kDifIrqTypeEvent, - kDifIrqTypeEvent, - kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_get_type(const dif_csrng_t *csrng, - dif_csrng_irq_t irq, dif_irq_type_t *type) { - if (csrng == NULL || type == NULL || irq < 0 || - irq > kDifCsrngIrqCsFatalErr) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_get_state(const dif_csrng_t *csrng, - dif_csrng_irq_state_snapshot_t *snapshot) { - if (csrng == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(csrng->base_addr, - (ptrdiff_t)CSRNG_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, (ptrdiff_t)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) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!csrng_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - csrng->base_addr, (ptrdiff_t)CSRNG_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_acknowledge_all(const dif_csrng_t *csrng) { - if (csrng == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(csrng->base_addr, (ptrdiff_t)CSRNG_INTR_STATE_REG_OFFSET, - UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_acknowledge(const dif_csrng_t *csrng, - dif_csrng_irq_t irq) { - if (csrng == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!csrng_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(csrng->base_addr, (ptrdiff_t)CSRNG_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_force(const dif_csrng_t *csrng, dif_csrng_irq_t irq, - const bool val) { - if (csrng == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!csrng_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(csrng->base_addr, (ptrdiff_t)CSRNG_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_get_enabled(const dif_csrng_t *csrng, - dif_csrng_irq_t irq, - dif_toggle_t *state) { - if (csrng == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!csrng_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - csrng->base_addr, (ptrdiff_t)CSRNG_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_set_enabled(const dif_csrng_t *csrng, - dif_csrng_irq_t irq, - dif_toggle_t state) { - if (csrng == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!csrng_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - csrng->base_addr, (ptrdiff_t)CSRNG_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(csrng->base_addr, (ptrdiff_t)CSRNG_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_disable_all( - const dif_csrng_t *csrng, dif_csrng_irq_enable_snapshot_t *snapshot) { - if (csrng == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(csrng->base_addr, - (ptrdiff_t)CSRNG_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(csrng->base_addr, (ptrdiff_t)CSRNG_INTR_ENABLE_REG_OFFSET, - 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_restore_all( - const dif_csrng_t *csrng, const dif_csrng_irq_enable_snapshot_t *snapshot) { - if (csrng == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(csrng->base_addr, (ptrdiff_t)CSRNG_INTR_ENABLE_REG_OFFSET, - *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_csrng_autogen.h b/sw/device/lib/dif/autogen/dif_csrng_autogen.h deleted file mode 100644 index 48b7a735885bb..0000000000000 --- a/sw/device/lib/dif/autogen/dif_csrng_autogen.h +++ /dev/null @@ -1,255 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_CSRNG_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_CSRNG_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief CSRNG Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to csrng. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_csrng { - /** - * The base address for the csrng hardware registers. - */ - mmio_region_t base_addr; -} dif_csrng_t; - -/** - * Creates a new handle for a(n) csrng peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the csrng peripheral. - * @param[out] csrng Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_init(mmio_region_t base_addr, dif_csrng_t *csrng); - -/** - * A csrng alert type. - */ -typedef enum dif_csrng_alert { - /** - * This alert is triggered when a recoverable alert occurs. Check the - * !!RECOV_ALERT_STS register to get more information. - */ - kDifCsrngAlertRecovAlert = 0, - /** - * This alert triggers (i) if an illegal state machine state is reached, or - * (ii) if an AES fatal alert condition occurs, or (iii) if a fatal integrity - * failure is detected on the TL-UL bus. - */ - kDifCsrngAlertFatalAlert = 1, -} dif_csrng_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param csrng A csrng handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_alert_force(const dif_csrng_t *csrng, - dif_csrng_alert_t alert); - -/** - * A csrng interrupt request type. - */ -typedef enum dif_csrng_irq { - /** - * Asserted when a command request is completed. - */ - kDifCsrngIrqCsCmdReqDone = 0, - /** - * Asserted when a request for entropy has been made. - */ - kDifCsrngIrqCsEntropyReq = 1, - /** - * Asserted when a hardware-attached CSRNG instance encounters a command - * exception - */ - kDifCsrngIrqCsHwInstExc = 2, - /** - * Asserted when a FIFO error or a fatal alert occurs. Check the !!ERR_CODE - * register to get more information. - */ - kDifCsrngIrqCsFatalErr = 3, -} dif_csrng_irq_t; - -/** - * 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()` - * and `dif_csrng_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_csrng_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param csrng A csrng handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_get_type(const dif_csrng_t *csrng, - dif_csrng_irq_t irq, dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param csrng A csrng handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_get_state(const dif_csrng_t *csrng, - dif_csrng_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param csrng A csrng handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param csrng A csrng handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_acknowledge_all(const dif_csrng_t *csrng); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param csrng A csrng handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_acknowledge(const dif_csrng_t *csrng, - dif_csrng_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param csrng A csrng handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_force(const dif_csrng_t *csrng, dif_csrng_irq_t irq, - const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_csrng_irq_disable_all()` and `dif_csrng_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_csrng_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param csrng A csrng handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_get_enabled(const dif_csrng_t *csrng, - dif_csrng_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param csrng A csrng handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_set_enabled(const dif_csrng_t *csrng, - dif_csrng_irq_t irq, dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param csrng A csrng handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_disable_all( - const dif_csrng_t *csrng, dif_csrng_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param csrng A csrng handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_csrng_irq_restore_all( - const dif_csrng_t *csrng, const dif_csrng_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_CSRNG_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_csrng_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_csrng_autogen_unittest.cc deleted file mode 100644 index 38df772362639..0000000000000 --- a/sw/device/lib/dif/autogen/dif_csrng_autogen_unittest.cc +++ /dev/null @@ -1,393 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_csrng_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "csrng_regs.h" // Generated. - -namespace dif_csrng_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class CsrngTest : public Test, public MmioTest { - protected: - dif_csrng_t csrng_ = {.base_addr = dev().region()}; -}; - -class InitTest : public CsrngTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_csrng_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_csrng_init(dev().region(), &csrng_)); -} - -class AlertForceTest : public CsrngTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_csrng_alert_force(nullptr, kDifCsrngAlertRecovAlert)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_csrng_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(CSRNG_ALERT_TEST_REG_OFFSET, - {{CSRNG_ALERT_TEST_RECOV_ALERT_BIT, true}}); - EXPECT_DIF_OK(dif_csrng_alert_force(&csrng_, kDifCsrngAlertRecovAlert)); - - // Force last alert. - EXPECT_WRITE32(CSRNG_ALERT_TEST_REG_OFFSET, - {{CSRNG_ALERT_TEST_FATAL_ALERT_BIT, true}}); - EXPECT_DIF_OK(dif_csrng_alert_force(&csrng_, kDifCsrngAlertFatalAlert)); -} - -class IrqGetTypeTest : public CsrngTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG( - dif_csrng_irq_get_type(nullptr, kDifCsrngIrqCsCmdReqDone, &type)); - - EXPECT_DIF_BADARG( - dif_csrng_irq_get_type(&csrng_, kDifCsrngIrqCsCmdReqDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_csrng_irq_get_type(nullptr, kDifCsrngIrqCsCmdReqDone, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_csrng_irq_get_type( - &csrng_, static_cast(kDifCsrngIrqCsFatalErr + 1), - &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK( - dif_csrng_irq_get_type(&csrng_, kDifCsrngIrqCsCmdReqDone, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public CsrngTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_csrng_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_csrng_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_csrng_irq_get_state(&csrng_, nullptr)); - - EXPECT_DIF_BADARG(dif_csrng_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_csrng_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(CSRNG_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_csrng_irq_get_state(&csrng_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public CsrngTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG( - dif_csrng_irq_is_pending(nullptr, kDifCsrngIrqCsCmdReqDone, &is_pending)); - - EXPECT_DIF_BADARG( - dif_csrng_irq_is_pending(&csrng_, kDifCsrngIrqCsCmdReqDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_csrng_irq_is_pending(nullptr, kDifCsrngIrqCsCmdReqDone, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_csrng_irq_is_pending( - &csrng_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(CSRNG_INTR_STATE_REG_OFFSET, - {{CSRNG_INTR_STATE_CS_CMD_REQ_DONE_BIT, true}}); - EXPECT_DIF_OK( - dif_csrng_irq_is_pending(&csrng_, kDifCsrngIrqCsCmdReqDone, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(CSRNG_INTR_STATE_REG_OFFSET, - {{CSRNG_INTR_STATE_CS_FATAL_ERR_BIT, false}}); - EXPECT_DIF_OK( - dif_csrng_irq_is_pending(&csrng_, kDifCsrngIrqCsFatalErr, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 4; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_csrng_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(CSRNG_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_csrng_irq_acknowledge_all(&csrng_)); -} - -class IrqAcknowledgeTest : public CsrngTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_csrng_irq_acknowledge(nullptr, kDifCsrngIrqCsCmdReqDone)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_csrng_irq_acknowledge(nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(CSRNG_INTR_STATE_REG_OFFSET, - {{CSRNG_INTR_STATE_CS_CMD_REQ_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_csrng_irq_acknowledge(&csrng_, kDifCsrngIrqCsCmdReqDone)); - - // Clear the last IRQ state. - EXPECT_WRITE32(CSRNG_INTR_STATE_REG_OFFSET, - {{CSRNG_INTR_STATE_CS_FATAL_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_csrng_irq_acknowledge(&csrng_, kDifCsrngIrqCsFatalErr)); -} - -class IrqForceTest : public CsrngTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_csrng_irq_force(nullptr, kDifCsrngIrqCsCmdReqDone, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_csrng_irq_force(nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(CSRNG_INTR_TEST_REG_OFFSET, - {{CSRNG_INTR_TEST_CS_CMD_REQ_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_csrng_irq_force(&csrng_, kDifCsrngIrqCsCmdReqDone, true)); - - // Force last IRQ. - EXPECT_WRITE32(CSRNG_INTR_TEST_REG_OFFSET, - {{CSRNG_INTR_TEST_CS_FATAL_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_csrng_irq_force(&csrng_, kDifCsrngIrqCsFatalErr, true)); -} - -class IrqGetEnabledTest : public CsrngTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG( - dif_csrng_irq_get_enabled(nullptr, kDifCsrngIrqCsCmdReqDone, &irq_state)); - - EXPECT_DIF_BADARG( - dif_csrng_irq_get_enabled(&csrng_, kDifCsrngIrqCsCmdReqDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_csrng_irq_get_enabled(nullptr, kDifCsrngIrqCsCmdReqDone, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_csrng_irq_get_enabled( - &csrng_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(CSRNG_INTR_ENABLE_REG_OFFSET, - {{CSRNG_INTR_ENABLE_CS_CMD_REQ_DONE_BIT, true}}); - EXPECT_DIF_OK( - dif_csrng_irq_get_enabled(&csrng_, kDifCsrngIrqCsCmdReqDone, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(CSRNG_INTR_ENABLE_REG_OFFSET, - {{CSRNG_INTR_ENABLE_CS_FATAL_ERR_BIT, false}}); - EXPECT_DIF_OK( - dif_csrng_irq_get_enabled(&csrng_, kDifCsrngIrqCsFatalErr, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public CsrngTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG( - dif_csrng_irq_set_enabled(nullptr, kDifCsrngIrqCsCmdReqDone, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_csrng_irq_set_enabled( - &csrng_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(CSRNG_INTR_ENABLE_REG_OFFSET, - {{CSRNG_INTR_ENABLE_CS_CMD_REQ_DONE_BIT, 0x1, true}}); - EXPECT_DIF_OK( - dif_csrng_irq_set_enabled(&csrng_, kDifCsrngIrqCsCmdReqDone, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(CSRNG_INTR_ENABLE_REG_OFFSET, - {{CSRNG_INTR_ENABLE_CS_FATAL_ERR_BIT, 0x1, false}}); - EXPECT_DIF_OK( - dif_csrng_irq_set_enabled(&csrng_, kDifCsrngIrqCsFatalErr, irq_state)); -} - -class IrqDisableAllTest : public CsrngTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_csrng_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_csrng_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_csrng_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(CSRNG_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_csrng_irq_disable_all(&csrng_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_csrng_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(CSRNG_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(CSRNG_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_csrng_irq_disable_all(&csrng_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_csrng_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(CSRNG_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(CSRNG_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_csrng_irq_disable_all(&csrng_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public CsrngTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_csrng_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_csrng_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_csrng_irq_restore_all(&csrng_, nullptr)); - - EXPECT_DIF_BADARG(dif_csrng_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_csrng_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(CSRNG_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_csrng_irq_restore_all(&csrng_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_csrng_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(CSRNG_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_csrng_irq_restore_all(&csrng_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_csrng_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_dma_autogen.c b/sw/device/lib/dif/autogen/dif_dma_autogen.c deleted file mode 100644 index 48f60494c6c81..0000000000000 --- a/sw/device/lib/dif/autogen/dif_dma_autogen.c +++ /dev/null @@ -1,260 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_dma_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "dma_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_init(mmio_region_t base_addr, dif_dma_t *dma) { - if (dma == NULL) { - return kDifBadArg; - } - - dma->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_dma_alert_force(const dif_dma_t *dma, dif_dma_alert_t alert) { - if (dma == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifDmaAlertFatalFault: - alert_idx = DMA_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(dma->base_addr, (ptrdiff_t)DMA_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool dma_get_irq_bit_index(dif_dma_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifDmaIrqDmaDone: - *index_out = DMA_INTR_COMMON_DMA_DONE_BIT; - break; - case kDifDmaIrqDmaChunkDone: - *index_out = DMA_INTR_COMMON_DMA_CHUNK_DONE_BIT; - break; - case kDifDmaIrqDmaError: - *index_out = DMA_INTR_COMMON_DMA_ERROR_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeStatus, - kDifIrqTypeStatus, - kDifIrqTypeStatus, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_get_type(const dif_dma_t *dma, dif_dma_irq_t irq, - dif_irq_type_t *type) { - if (dma == NULL || type == NULL || irq < 0 || irq > kDifDmaIrqDmaError) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_get_state(const dif_dma_t *dma, - dif_dma_irq_state_snapshot_t *snapshot) { - if (dma == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = - mmio_region_read32(dma->base_addr, (ptrdiff_t)DMA_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_acknowledge_state( - const dif_dma_t *dma, dif_dma_irq_state_snapshot_t snapshot) { - if (dma == NULL) { - return kDifBadArg; - } - - mmio_region_write32(dma->base_addr, (ptrdiff_t)DMA_INTR_STATE_REG_OFFSET, - snapshot); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_is_pending(const dif_dma_t *dma, dif_dma_irq_t irq, - bool *is_pending) { - if (dma == NULL || is_pending == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!dma_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = - mmio_region_read32(dma->base_addr, (ptrdiff_t)DMA_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_acknowledge_all(const dif_dma_t *dma) { - if (dma == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(dma->base_addr, (ptrdiff_t)DMA_INTR_STATE_REG_OFFSET, - UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_acknowledge(const dif_dma_t *dma, dif_dma_irq_t irq) { - if (dma == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!dma_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(dma->base_addr, (ptrdiff_t)DMA_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_force(const dif_dma_t *dma, dif_dma_irq_t irq, - const bool val) { - if (dma == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!dma_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(dma->base_addr, (ptrdiff_t)DMA_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_get_enabled(const dif_dma_t *dma, dif_dma_irq_t irq, - dif_toggle_t *state) { - if (dma == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!dma_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = - mmio_region_read32(dma->base_addr, (ptrdiff_t)DMA_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_set_enabled(const dif_dma_t *dma, dif_dma_irq_t irq, - dif_toggle_t state) { - if (dma == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!dma_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = - mmio_region_read32(dma->base_addr, (ptrdiff_t)DMA_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(dma->base_addr, (ptrdiff_t)DMA_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_disable_all(const dif_dma_t *dma, - dif_dma_irq_enable_snapshot_t *snapshot) { - if (dma == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(dma->base_addr, - (ptrdiff_t)DMA_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(dma->base_addr, (ptrdiff_t)DMA_INTR_ENABLE_REG_OFFSET, - 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_restore_all( - const dif_dma_t *dma, const dif_dma_irq_enable_snapshot_t *snapshot) { - if (dma == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(dma->base_addr, (ptrdiff_t)DMA_INTR_ENABLE_REG_OFFSET, - *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_dma_autogen.h b/sw/device/lib/dif/autogen/dif_dma_autogen.h deleted file mode 100644 index be8a88f00e93d..0000000000000 --- a/sw/device/lib/dif/autogen/dif_dma_autogen.h +++ /dev/null @@ -1,240 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_DMA_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_DMA_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief DMA Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to dma. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_dma { - /** - * The base address for the dma hardware registers. - */ - mmio_region_t base_addr; -} dif_dma_t; - -/** - * Creates a new handle for a(n) dma peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the dma peripheral. - * @param[out] dma Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_init(mmio_region_t base_addr, dif_dma_t *dma); - -/** - * A dma alert type. - */ -typedef enum dif_dma_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifDmaAlertFatalFault = 0, -} dif_dma_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param dma A dma handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_alert_force(const dif_dma_t *dma, dif_dma_alert_t alert); - -/** - * A dma interrupt request type. - */ -typedef enum dif_dma_irq { - /** - * DMA operation has been completed. - */ - kDifDmaIrqDmaDone = 0, - /** - * Indicates the transfer of a single chunk has been completed. - */ - kDifDmaIrqDmaChunkDone = 1, - /** - * DMA error has occurred. DMA_STATUS.error_code register shows the details. - */ - kDifDmaIrqDmaError = 2, -} dif_dma_irq_t; - -/** - * A snapshot of the state of the interrupts for this IP. - * - * This is an opaque type, to be used with the `dif_dma_irq_get_state()` - * and `dif_dma_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_dma_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param dma A dma handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_get_type(const dif_dma_t *dma, dif_dma_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param dma A dma handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_get_state(const dif_dma_t *dma, - dif_dma_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param dma A dma handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_is_pending(const dif_dma_t *dma, dif_dma_irq_t irq, - bool *is_pending); - -/** - * Acknowledges all interrupts that were pending at the time of the state - * snapshot. - * - * @param dma A dma handle. - * @param snapshot Interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_acknowledge_state( - const dif_dma_t *dma, dif_dma_irq_state_snapshot_t snapshot); - -/** - * Acknowledges all interrupts, indicating to the hardware that all - * interrupts have been successfully serviced. - * - * @param dma A dma handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_acknowledge_all(const dif_dma_t *dma); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param dma A dma handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_acknowledge(const dif_dma_t *dma, dif_dma_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param dma A dma handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_force(const dif_dma_t *dma, dif_dma_irq_t irq, - const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_dma_irq_disable_all()` and `dif_dma_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_dma_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param dma A dma handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_get_enabled(const dif_dma_t *dma, dif_dma_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param dma A dma handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_set_enabled(const dif_dma_t *dma, dif_dma_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param dma A dma handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_disable_all(const dif_dma_t *dma, - dif_dma_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param dma A dma handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_dma_irq_restore_all( - const dif_dma_t *dma, const dif_dma_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_DMA_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_dma_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_dma_autogen_unittest.cc deleted file mode 100644 index 5fbac4ab10798..0000000000000 --- a/sw/device/lib/dif/autogen/dif_dma_autogen_unittest.cc +++ /dev/null @@ -1,373 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_dma_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "dma_regs.h" // Generated. - -namespace dif_dma_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class DmaTest : public Test, public MmioTest { - protected: - dif_dma_t dma_ = {.base_addr = dev().region()}; -}; - -class InitTest : public DmaTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_dma_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_dma_init(dev().region(), &dma_)); -} - -class AlertForceTest : public DmaTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_dma_alert_force(nullptr, kDifDmaAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_dma_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(DMA_ALERT_TEST_REG_OFFSET, - {{DMA_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_dma_alert_force(&dma_, kDifDmaAlertFatalFault)); -} - -class IrqGetTypeTest : public DmaTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_dma_irq_get_type(nullptr, kDifDmaIrqDmaDone, &type)); - - EXPECT_DIF_BADARG(dif_dma_irq_get_type(&dma_, kDifDmaIrqDmaDone, nullptr)); - - EXPECT_DIF_BADARG(dif_dma_irq_get_type(nullptr, kDifDmaIrqDmaDone, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_dma_irq_get_type( - &dma_, static_cast(kDifDmaIrqDmaError + 1), &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_dma_irq_get_type(&dma_, kDifDmaIrqDmaDone, &type)); - EXPECT_EQ(type, kDifIrqTypeStatus); -} - -class IrqGetStateTest : public DmaTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_dma_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_dma_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_dma_irq_get_state(&dma_, nullptr)); - - EXPECT_DIF_BADARG(dif_dma_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_dma_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(DMA_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_dma_irq_get_state(&dma_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, SuccessNoneRaised) { - dif_dma_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(DMA_INTR_STATE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_dma_irq_get_state(&dma_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -class IrqIsPendingTest : public DmaTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG( - dif_dma_irq_is_pending(nullptr, kDifDmaIrqDmaDone, &is_pending)); - - EXPECT_DIF_BADARG(dif_dma_irq_is_pending(&dma_, kDifDmaIrqDmaDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_dma_irq_is_pending(nullptr, kDifDmaIrqDmaDone, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_dma_irq_is_pending( - &dma_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(DMA_INTR_STATE_REG_OFFSET, - {{DMA_INTR_STATE_DMA_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_dma_irq_is_pending(&dma_, kDifDmaIrqDmaDone, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(DMA_INTR_STATE_REG_OFFSET, - {{DMA_INTR_STATE_DMA_ERROR_BIT, false}}); - EXPECT_DIF_OK(dif_dma_irq_is_pending(&dma_, kDifDmaIrqDmaError, &irq_state)); - EXPECT_FALSE(irq_state); -} - -class AcknowledgeStateTest : public DmaTest {}; - -TEST_F(AcknowledgeStateTest, NullArgs) { - dif_dma_irq_state_snapshot_t irq_snapshot = 0; - EXPECT_DIF_BADARG(dif_dma_irq_acknowledge_state(nullptr, irq_snapshot)); -} - -TEST_F(AcknowledgeStateTest, AckSnapshot) { - constexpr uint32_t num_irqs = 3; - constexpr uint32_t irq_mask = (uint64_t{1} << num_irqs) - 1; - dif_dma_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(DMA_INTR_STATE_REG_OFFSET, irq_snapshot); - EXPECT_DIF_OK(dif_dma_irq_acknowledge_state(&dma_, irq_snapshot)); - } -} - -TEST_F(AcknowledgeStateTest, SuccessNoneRaised) { - dif_dma_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(DMA_INTR_STATE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_dma_irq_get_state(&dma_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -class AcknowledgeAllTest : public DmaTest {}; - -TEST_F(AcknowledgeAllTest, NullArgs) { - EXPECT_DIF_BADARG(dif_dma_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(DMA_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_dma_irq_acknowledge_all(&dma_)); -} - -class IrqAcknowledgeTest : public DmaTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG(dif_dma_irq_acknowledge(nullptr, kDifDmaIrqDmaDone)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_dma_irq_acknowledge(nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(DMA_INTR_STATE_REG_OFFSET, - {{DMA_INTR_STATE_DMA_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_dma_irq_acknowledge(&dma_, kDifDmaIrqDmaDone)); - - // Clear the last IRQ state. - EXPECT_WRITE32(DMA_INTR_STATE_REG_OFFSET, - {{DMA_INTR_STATE_DMA_ERROR_BIT, true}}); - EXPECT_DIF_OK(dif_dma_irq_acknowledge(&dma_, kDifDmaIrqDmaError)); -} - -class IrqForceTest : public DmaTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_dma_irq_force(nullptr, kDifDmaIrqDmaDone, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_dma_irq_force(nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(DMA_INTR_TEST_REG_OFFSET, - {{DMA_INTR_TEST_DMA_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_dma_irq_force(&dma_, kDifDmaIrqDmaDone, true)); - - // Force last IRQ. - EXPECT_WRITE32(DMA_INTR_TEST_REG_OFFSET, - {{DMA_INTR_TEST_DMA_ERROR_BIT, true}}); - EXPECT_DIF_OK(dif_dma_irq_force(&dma_, kDifDmaIrqDmaError, true)); -} - -class IrqGetEnabledTest : public DmaTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG( - dif_dma_irq_get_enabled(nullptr, kDifDmaIrqDmaDone, &irq_state)); - - EXPECT_DIF_BADARG(dif_dma_irq_get_enabled(&dma_, kDifDmaIrqDmaDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_dma_irq_get_enabled(nullptr, kDifDmaIrqDmaDone, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_dma_irq_get_enabled( - &dma_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(DMA_INTR_ENABLE_REG_OFFSET, - {{DMA_INTR_ENABLE_DMA_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_dma_irq_get_enabled(&dma_, kDifDmaIrqDmaDone, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(DMA_INTR_ENABLE_REG_OFFSET, - {{DMA_INTR_ENABLE_DMA_ERROR_BIT, false}}); - EXPECT_DIF_OK(dif_dma_irq_get_enabled(&dma_, kDifDmaIrqDmaError, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public DmaTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG( - dif_dma_irq_set_enabled(nullptr, kDifDmaIrqDmaDone, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_dma_irq_set_enabled( - &dma_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(DMA_INTR_ENABLE_REG_OFFSET, - {{DMA_INTR_ENABLE_DMA_DONE_BIT, 0x1, true}}); - EXPECT_DIF_OK(dif_dma_irq_set_enabled(&dma_, kDifDmaIrqDmaDone, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(DMA_INTR_ENABLE_REG_OFFSET, - {{DMA_INTR_ENABLE_DMA_ERROR_BIT, 0x1, false}}); - EXPECT_DIF_OK(dif_dma_irq_set_enabled(&dma_, kDifDmaIrqDmaError, irq_state)); -} - -class IrqDisableAllTest : public DmaTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_dma_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_dma_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_dma_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(DMA_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_dma_irq_disable_all(&dma_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_dma_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(DMA_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(DMA_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_dma_irq_disable_all(&dma_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_dma_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(DMA_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(DMA_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_dma_irq_disable_all(&dma_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public DmaTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_dma_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_dma_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_dma_irq_restore_all(&dma_, nullptr)); - - EXPECT_DIF_BADARG(dif_dma_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_dma_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(DMA_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_dma_irq_restore_all(&dma_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_dma_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(DMA_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_dma_irq_restore_all(&dma_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_dma_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_edn_autogen.c b/sw/device/lib/dif/autogen/dif_edn_autogen.c deleted file mode 100644 index 39d9c827a6ce1..0000000000000 --- a/sw/device/lib/dif/autogen/dif_edn_autogen.c +++ /dev/null @@ -1,259 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_edn_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "edn_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_init(mmio_region_t base_addr, dif_edn_t *edn) { - if (edn == NULL) { - return kDifBadArg; - } - - edn->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_edn_alert_force(const dif_edn_t *edn, dif_edn_alert_t alert) { - if (edn == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifEdnAlertRecovAlert: - alert_idx = EDN_ALERT_TEST_RECOV_ALERT_BIT; - break; - case kDifEdnAlertFatalAlert: - alert_idx = EDN_ALERT_TEST_FATAL_ALERT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(edn->base_addr, (ptrdiff_t)EDN_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool edn_get_irq_bit_index(dif_edn_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifEdnIrqEdnCmdReqDone: - *index_out = EDN_INTR_COMMON_EDN_CMD_REQ_DONE_BIT; - break; - case kDifEdnIrqEdnFatalErr: - *index_out = EDN_INTR_COMMON_EDN_FATAL_ERR_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, - kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_get_type(const dif_edn_t *edn, dif_edn_irq_t irq, - dif_irq_type_t *type) { - if (edn == NULL || type == NULL || irq < 0 || irq > kDifEdnIrqEdnFatalErr) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_get_state(const dif_edn_t *edn, - dif_edn_irq_state_snapshot_t *snapshot) { - if (edn == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = - mmio_region_read32(edn->base_addr, (ptrdiff_t)EDN_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, (ptrdiff_t)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) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!edn_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = - mmio_region_read32(edn->base_addr, (ptrdiff_t)EDN_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_acknowledge_all(const dif_edn_t *edn) { - if (edn == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(edn->base_addr, (ptrdiff_t)EDN_INTR_STATE_REG_OFFSET, - UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_acknowledge(const dif_edn_t *edn, dif_edn_irq_t irq) { - if (edn == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!edn_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(edn->base_addr, (ptrdiff_t)EDN_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_force(const dif_edn_t *edn, dif_edn_irq_t irq, - const bool val) { - if (edn == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!edn_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(edn->base_addr, (ptrdiff_t)EDN_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_get_enabled(const dif_edn_t *edn, dif_edn_irq_t irq, - dif_toggle_t *state) { - if (edn == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!edn_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = - mmio_region_read32(edn->base_addr, (ptrdiff_t)EDN_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_set_enabled(const dif_edn_t *edn, dif_edn_irq_t irq, - dif_toggle_t state) { - if (edn == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!edn_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = - mmio_region_read32(edn->base_addr, (ptrdiff_t)EDN_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(edn->base_addr, (ptrdiff_t)EDN_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_disable_all(const dif_edn_t *edn, - dif_edn_irq_enable_snapshot_t *snapshot) { - if (edn == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(edn->base_addr, - (ptrdiff_t)EDN_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(edn->base_addr, (ptrdiff_t)EDN_INTR_ENABLE_REG_OFFSET, - 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_restore_all( - const dif_edn_t *edn, const dif_edn_irq_enable_snapshot_t *snapshot) { - if (edn == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(edn->base_addr, (ptrdiff_t)EDN_INTR_ENABLE_REG_OFFSET, - *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_edn_autogen.h b/sw/device/lib/dif/autogen/dif_edn_autogen.h deleted file mode 100644 index 0386181954e78..0000000000000 --- a/sw/device/lib/dif/autogen/dif_edn_autogen.h +++ /dev/null @@ -1,241 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_EDN_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_EDN_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief EDN Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to edn. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_edn { - /** - * The base address for the edn hardware registers. - */ - mmio_region_t base_addr; -} dif_edn_t; - -/** - * Creates a new handle for a(n) edn peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the edn peripheral. - * @param[out] edn Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_init(mmio_region_t base_addr, dif_edn_t *edn); - -/** - * A edn alert type. - */ -typedef enum dif_edn_alert { - /** - * This alert is triggered when entropy bus data matches on consecutive clock - * cycles. - */ - kDifEdnAlertRecovAlert = 0, - /** - * This alert triggers (i) if an illegal state machine state is reached, or - * (ii) if a fatal integrity failure is detected on the TL-UL bus. - */ - kDifEdnAlertFatalAlert = 1, -} dif_edn_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param edn A edn handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_alert_force(const dif_edn_t *edn, dif_edn_alert_t alert); - -/** - * A edn interrupt request type. - */ -typedef enum dif_edn_irq { - /** - * Asserted when a software CSRNG request has completed. - */ - kDifEdnIrqEdnCmdReqDone = 0, - /** - * Asserted when a FIFO error occurs. - */ - kDifEdnIrqEdnFatalErr = 1, -} dif_edn_irq_t; - -/** - * 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()` - * and `dif_edn_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_edn_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param edn A edn handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_get_type(const dif_edn_t *edn, dif_edn_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param edn A edn handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_get_state(const dif_edn_t *edn, - dif_edn_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param edn A edn handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param edn A edn handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_acknowledge_all(const dif_edn_t *edn); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param edn A edn handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_acknowledge(const dif_edn_t *edn, dif_edn_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param edn A edn handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_force(const dif_edn_t *edn, dif_edn_irq_t irq, - const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_edn_irq_disable_all()` and `dif_edn_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_edn_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param edn A edn handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_get_enabled(const dif_edn_t *edn, dif_edn_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param edn A edn handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_set_enabled(const dif_edn_t *edn, dif_edn_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param edn A edn handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_disable_all(const dif_edn_t *edn, - dif_edn_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param edn A edn handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_edn_irq_restore_all( - const dif_edn_t *edn, const dif_edn_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_EDN_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_edn_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_edn_autogen_unittest.cc deleted file mode 100644 index 87ebef50c3135..0000000000000 --- a/sw/device/lib/dif/autogen/dif_edn_autogen_unittest.cc +++ /dev/null @@ -1,389 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_edn_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "edn_regs.h" // Generated. - -namespace dif_edn_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class EdnTest : public Test, public MmioTest { - protected: - dif_edn_t edn_ = {.base_addr = dev().region()}; -}; - -class InitTest : public EdnTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_edn_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_edn_init(dev().region(), &edn_)); -} - -class AlertForceTest : public EdnTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_edn_alert_force(nullptr, kDifEdnAlertRecovAlert)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_edn_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(EDN_ALERT_TEST_REG_OFFSET, - {{EDN_ALERT_TEST_RECOV_ALERT_BIT, true}}); - EXPECT_DIF_OK(dif_edn_alert_force(&edn_, kDifEdnAlertRecovAlert)); - - // Force last alert. - EXPECT_WRITE32(EDN_ALERT_TEST_REG_OFFSET, - {{EDN_ALERT_TEST_FATAL_ALERT_BIT, true}}); - EXPECT_DIF_OK(dif_edn_alert_force(&edn_, kDifEdnAlertFatalAlert)); -} - -class IrqGetTypeTest : public EdnTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG( - dif_edn_irq_get_type(nullptr, kDifEdnIrqEdnCmdReqDone, &type)); - - EXPECT_DIF_BADARG( - dif_edn_irq_get_type(&edn_, kDifEdnIrqEdnCmdReqDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_edn_irq_get_type(nullptr, kDifEdnIrqEdnCmdReqDone, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_edn_irq_get_type( - &edn_, static_cast(kDifEdnIrqEdnFatalErr + 1), &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_edn_irq_get_type(&edn_, kDifEdnIrqEdnCmdReqDone, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public EdnTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_edn_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_edn_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_edn_irq_get_state(&edn_, nullptr)); - - EXPECT_DIF_BADARG(dif_edn_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_edn_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(EDN_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_edn_irq_get_state(&edn_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public EdnTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG( - dif_edn_irq_is_pending(nullptr, kDifEdnIrqEdnCmdReqDone, &is_pending)); - - EXPECT_DIF_BADARG( - dif_edn_irq_is_pending(&edn_, kDifEdnIrqEdnCmdReqDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_edn_irq_is_pending(nullptr, kDifEdnIrqEdnCmdReqDone, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_edn_irq_is_pending( - &edn_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(EDN_INTR_STATE_REG_OFFSET, - {{EDN_INTR_STATE_EDN_CMD_REQ_DONE_BIT, true}}); - EXPECT_DIF_OK( - dif_edn_irq_is_pending(&edn_, kDifEdnIrqEdnCmdReqDone, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(EDN_INTR_STATE_REG_OFFSET, - {{EDN_INTR_STATE_EDN_FATAL_ERR_BIT, false}}); - EXPECT_DIF_OK( - dif_edn_irq_is_pending(&edn_, kDifEdnIrqEdnFatalErr, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 2; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_edn_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(EDN_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_edn_irq_acknowledge_all(&edn_)); -} - -class IrqAcknowledgeTest : public EdnTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG(dif_edn_irq_acknowledge(nullptr, kDifEdnIrqEdnCmdReqDone)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_edn_irq_acknowledge(nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(EDN_INTR_STATE_REG_OFFSET, - {{EDN_INTR_STATE_EDN_CMD_REQ_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_edn_irq_acknowledge(&edn_, kDifEdnIrqEdnCmdReqDone)); - - // Clear the last IRQ state. - EXPECT_WRITE32(EDN_INTR_STATE_REG_OFFSET, - {{EDN_INTR_STATE_EDN_FATAL_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_edn_irq_acknowledge(&edn_, kDifEdnIrqEdnFatalErr)); -} - -class IrqForceTest : public EdnTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_edn_irq_force(nullptr, kDifEdnIrqEdnCmdReqDone, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_edn_irq_force(nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(EDN_INTR_TEST_REG_OFFSET, - {{EDN_INTR_TEST_EDN_CMD_REQ_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_edn_irq_force(&edn_, kDifEdnIrqEdnCmdReqDone, true)); - - // Force last IRQ. - EXPECT_WRITE32(EDN_INTR_TEST_REG_OFFSET, - {{EDN_INTR_TEST_EDN_FATAL_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_edn_irq_force(&edn_, kDifEdnIrqEdnFatalErr, true)); -} - -class IrqGetEnabledTest : public EdnTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG( - dif_edn_irq_get_enabled(nullptr, kDifEdnIrqEdnCmdReqDone, &irq_state)); - - EXPECT_DIF_BADARG( - dif_edn_irq_get_enabled(&edn_, kDifEdnIrqEdnCmdReqDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_edn_irq_get_enabled(nullptr, kDifEdnIrqEdnCmdReqDone, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_edn_irq_get_enabled( - &edn_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(EDN_INTR_ENABLE_REG_OFFSET, - {{EDN_INTR_ENABLE_EDN_CMD_REQ_DONE_BIT, true}}); - EXPECT_DIF_OK( - dif_edn_irq_get_enabled(&edn_, kDifEdnIrqEdnCmdReqDone, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(EDN_INTR_ENABLE_REG_OFFSET, - {{EDN_INTR_ENABLE_EDN_FATAL_ERR_BIT, false}}); - EXPECT_DIF_OK( - dif_edn_irq_get_enabled(&edn_, kDifEdnIrqEdnFatalErr, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public EdnTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG( - dif_edn_irq_set_enabled(nullptr, kDifEdnIrqEdnCmdReqDone, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_edn_irq_set_enabled( - &edn_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(EDN_INTR_ENABLE_REG_OFFSET, - {{EDN_INTR_ENABLE_EDN_CMD_REQ_DONE_BIT, 0x1, true}}); - EXPECT_DIF_OK( - dif_edn_irq_set_enabled(&edn_, kDifEdnIrqEdnCmdReqDone, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(EDN_INTR_ENABLE_REG_OFFSET, - {{EDN_INTR_ENABLE_EDN_FATAL_ERR_BIT, 0x1, false}}); - EXPECT_DIF_OK( - dif_edn_irq_set_enabled(&edn_, kDifEdnIrqEdnFatalErr, irq_state)); -} - -class IrqDisableAllTest : public EdnTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_edn_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_edn_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_edn_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(EDN_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_edn_irq_disable_all(&edn_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_edn_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(EDN_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(EDN_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_edn_irq_disable_all(&edn_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_edn_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(EDN_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(EDN_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_edn_irq_disable_all(&edn_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public EdnTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_edn_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_edn_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_edn_irq_restore_all(&edn_, nullptr)); - - EXPECT_DIF_BADARG(dif_edn_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_edn_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(EDN_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_edn_irq_restore_all(&edn_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_edn_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(EDN_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_edn_irq_restore_all(&edn_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_edn_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_entropy_src_autogen.c b/sw/device/lib/dif/autogen/dif_entropy_src_autogen.c deleted file mode 100644 index a79f74172733d..0000000000000 --- a/sw/device/lib/dif/autogen/dif_entropy_src_autogen.c +++ /dev/null @@ -1,285 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_entropy_src_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "entropy_src_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_init(mmio_region_t base_addr, - dif_entropy_src_t *entropy_src) { - if (entropy_src == NULL) { - return kDifBadArg; - } - - entropy_src->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_entropy_src_alert_force(const dif_entropy_src_t *entropy_src, - dif_entropy_src_alert_t alert) { - if (entropy_src == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifEntropySrcAlertRecovAlert: - alert_idx = ENTROPY_SRC_ALERT_TEST_RECOV_ALERT_BIT; - break; - case kDifEntropySrcAlertFatalAlert: - alert_idx = ENTROPY_SRC_ALERT_TEST_FATAL_ALERT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(entropy_src->base_addr, - (ptrdiff_t)ENTROPY_SRC_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool entropy_src_get_irq_bit_index(dif_entropy_src_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifEntropySrcIrqEsEntropyValid: - *index_out = ENTROPY_SRC_INTR_COMMON_ES_ENTROPY_VALID_BIT; - break; - case kDifEntropySrcIrqEsHealthTestFailed: - *index_out = ENTROPY_SRC_INTR_COMMON_ES_HEALTH_TEST_FAILED_BIT; - break; - case kDifEntropySrcIrqEsObserveFifoReady: - *index_out = ENTROPY_SRC_INTR_COMMON_ES_OBSERVE_FIFO_READY_BIT; - break; - case kDifEntropySrcIrqEsFatalErr: - *index_out = ENTROPY_SRC_INTR_COMMON_ES_FATAL_ERR_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, - kDifIrqTypeEvent, - kDifIrqTypeEvent, - kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_get_type(const dif_entropy_src_t *entropy_src, - dif_entropy_src_irq_t irq, - dif_irq_type_t *type) { - if (entropy_src == NULL || type == NULL || irq < 0 || - irq > kDifEntropySrcIrqEsFatalErr) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_get_state( - const dif_entropy_src_t *entropy_src, - dif_entropy_src_irq_state_snapshot_t *snapshot) { - if (entropy_src == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(entropy_src->base_addr, - (ptrdiff_t)ENTROPY_SRC_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, - (ptrdiff_t)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) { - if (entropy_src == NULL || is_pending == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!entropy_src_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - entropy_src->base_addr, (ptrdiff_t)ENTROPY_SRC_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_acknowledge_all( - const dif_entropy_src_t *entropy_src) { - if (entropy_src == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(entropy_src->base_addr, - (ptrdiff_t)ENTROPY_SRC_INTR_STATE_REG_OFFSET, UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_acknowledge( - const dif_entropy_src_t *entropy_src, dif_entropy_src_irq_t irq) { - if (entropy_src == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!entropy_src_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(entropy_src->base_addr, - (ptrdiff_t)ENTROPY_SRC_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_force(const dif_entropy_src_t *entropy_src, - dif_entropy_src_irq_t irq, - const bool val) { - if (entropy_src == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!entropy_src_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(entropy_src->base_addr, - (ptrdiff_t)ENTROPY_SRC_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_get_enabled( - const dif_entropy_src_t *entropy_src, dif_entropy_src_irq_t irq, - dif_toggle_t *state) { - if (entropy_src == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!entropy_src_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - entropy_src->base_addr, (ptrdiff_t)ENTROPY_SRC_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_set_enabled( - const dif_entropy_src_t *entropy_src, dif_entropy_src_irq_t irq, - dif_toggle_t state) { - if (entropy_src == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!entropy_src_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - entropy_src->base_addr, (ptrdiff_t)ENTROPY_SRC_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(entropy_src->base_addr, - (ptrdiff_t)ENTROPY_SRC_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_disable_all( - const dif_entropy_src_t *entropy_src, - dif_entropy_src_irq_enable_snapshot_t *snapshot) { - if (entropy_src == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32( - entropy_src->base_addr, (ptrdiff_t)ENTROPY_SRC_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(entropy_src->base_addr, - (ptrdiff_t)ENTROPY_SRC_INTR_ENABLE_REG_OFFSET, 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_restore_all( - const dif_entropy_src_t *entropy_src, - const dif_entropy_src_irq_enable_snapshot_t *snapshot) { - if (entropy_src == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(entropy_src->base_addr, - (ptrdiff_t)ENTROPY_SRC_INTR_ENABLE_REG_OFFSET, *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_entropy_src_autogen.h b/sw/device/lib/dif/autogen/dif_entropy_src_autogen.h deleted file mode 100644 index 95091e3fd23ee..0000000000000 --- a/sw/device/lib/dif/autogen/dif_entropy_src_autogen.h +++ /dev/null @@ -1,269 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_ENTROPY_SRC_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_ENTROPY_SRC_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief ENTROPY_SRC Device Interface - * Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to entropy_src. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_entropy_src { - /** - * The base address for the entropy_src hardware registers. - */ - mmio_region_t base_addr; -} dif_entropy_src_t; - -/** - * Creates a new handle for a(n) entropy_src peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the entropy_src peripheral. - * @param[out] entropy_src Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_init(mmio_region_t base_addr, - dif_entropy_src_t *entropy_src); - -/** - * A entropy_src alert type. - */ -typedef enum dif_entropy_src_alert { - /** - * This alert is triggered upon the alert health test threshold criteria not - * met. - */ - kDifEntropySrcAlertRecovAlert = 0, - /** - * This alert triggers for any condition detected in the !!ERR_CODE register, - * which includes FIFO errors, COUNTER errors, FSM state errors, and also when - * integrity failures are detected on the TL-UL bus. - */ - kDifEntropySrcAlertFatalAlert = 1, -} dif_entropy_src_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param entropy_src A entropy_src handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_alert_force(const dif_entropy_src_t *entropy_src, - dif_entropy_src_alert_t alert); - -/** - * A entropy_src interrupt request type. - */ -typedef enum dif_entropy_src_irq { - /** - * Asserted when entropy source bits are available for firmware for - * consumption via !!ENTROPY_DATA register. - */ - kDifEntropySrcIrqEsEntropyValid = 0, - /** - * Asserted whenever the main state machine is in the alert state, e.g., due - * to health tests failing and reaching the threshold value configured in - * !!ALERT_THRESHOLD. - */ - kDifEntropySrcIrqEsHealthTestFailed = 1, - /** - * Asserted when the observe FIFO has filled to the configured threshold level - * (see !!OBSERVE_FIFO_THRESH). - */ - kDifEntropySrcIrqEsObserveFifoReady = 2, - /** - * Asserted when an fatal error condition is met, e.g., upon FIFO errors, or - * if an illegal state machine state is reached. - */ - kDifEntropySrcIrqEsFatalErr = 3, -} dif_entropy_src_irq_t; - -/** - * 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()` - * and `dif_entropy_src_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_entropy_src_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param entropy_src A entropy_src handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_get_type(const dif_entropy_src_t *entropy_src, - dif_entropy_src_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param entropy_src A entropy_src handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_get_state( - const dif_entropy_src_t *entropy_src, - dif_entropy_src_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param entropy_src A entropy_src handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param entropy_src A entropy_src handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_acknowledge_all( - const dif_entropy_src_t *entropy_src); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param entropy_src A entropy_src handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_acknowledge( - const dif_entropy_src_t *entropy_src, dif_entropy_src_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param entropy_src A entropy_src handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_force(const dif_entropy_src_t *entropy_src, - dif_entropy_src_irq_t irq, - const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_entropy_src_irq_disable_all()` and `dif_entropy_src_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_entropy_src_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param entropy_src A entropy_src handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_get_enabled( - const dif_entropy_src_t *entropy_src, dif_entropy_src_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param entropy_src A entropy_src handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_set_enabled( - const dif_entropy_src_t *entropy_src, dif_entropy_src_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param entropy_src A entropy_src handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_disable_all( - const dif_entropy_src_t *entropy_src, - dif_entropy_src_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param entropy_src A entropy_src handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_entropy_src_irq_restore_all( - const dif_entropy_src_t *entropy_src, - const dif_entropy_src_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_ENTROPY_SRC_AUTOGEN_H_ 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 deleted file mode 100644 index 9505aef1fbd44..0000000000000 --- a/sw/device/lib/dif/autogen/dif_entropy_src_autogen_unittest.cc +++ /dev/null @@ -1,403 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_entropy_src_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "entropy_src_regs.h" // Generated. - -namespace dif_entropy_src_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class EntropySrcTest : public Test, public MmioTest { - protected: - dif_entropy_src_t entropy_src_ = {.base_addr = dev().region()}; -}; - -class InitTest : public EntropySrcTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_entropy_src_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_entropy_src_init(dev().region(), &entropy_src_)); -} - -class AlertForceTest : public EntropySrcTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_entropy_src_alert_force(nullptr, kDifEntropySrcAlertRecovAlert)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG(dif_entropy_src_alert_force( - nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(ENTROPY_SRC_ALERT_TEST_REG_OFFSET, - {{ENTROPY_SRC_ALERT_TEST_RECOV_ALERT_BIT, true}}); - EXPECT_DIF_OK(dif_entropy_src_alert_force(&entropy_src_, - kDifEntropySrcAlertRecovAlert)); - - // Force last alert. - EXPECT_WRITE32(ENTROPY_SRC_ALERT_TEST_REG_OFFSET, - {{ENTROPY_SRC_ALERT_TEST_FATAL_ALERT_BIT, true}}); - EXPECT_DIF_OK(dif_entropy_src_alert_force(&entropy_src_, - kDifEntropySrcAlertFatalAlert)); -} - -class IrqGetTypeTest : public EntropySrcTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_entropy_src_irq_get_type( - nullptr, kDifEntropySrcIrqEsEntropyValid, &type)); - - EXPECT_DIF_BADARG(dif_entropy_src_irq_get_type( - &entropy_src_, kDifEntropySrcIrqEsEntropyValid, nullptr)); - - EXPECT_DIF_BADARG(dif_entropy_src_irq_get_type( - nullptr, kDifEntropySrcIrqEsEntropyValid, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_entropy_src_irq_get_type( - &entropy_src_, - static_cast(kDifEntropySrcIrqEsFatalErr + 1), - &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_entropy_src_irq_get_type( - &entropy_src_, kDifEntropySrcIrqEsEntropyValid, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public EntropySrcTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_entropy_src_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_entropy_src_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_entropy_src_irq_get_state(&entropy_src_, nullptr)); - - EXPECT_DIF_BADARG(dif_entropy_src_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_entropy_src_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(ENTROPY_SRC_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_entropy_src_irq_get_state(&entropy_src_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public EntropySrcTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG(dif_entropy_src_irq_is_pending( - nullptr, kDifEntropySrcIrqEsEntropyValid, &is_pending)); - - EXPECT_DIF_BADARG(dif_entropy_src_irq_is_pending( - &entropy_src_, kDifEntropySrcIrqEsEntropyValid, nullptr)); - - EXPECT_DIF_BADARG(dif_entropy_src_irq_is_pending( - nullptr, kDifEntropySrcIrqEsEntropyValid, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_entropy_src_irq_is_pending( - &entropy_src_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(ENTROPY_SRC_INTR_STATE_REG_OFFSET, - {{ENTROPY_SRC_INTR_STATE_ES_ENTROPY_VALID_BIT, true}}); - EXPECT_DIF_OK(dif_entropy_src_irq_is_pending( - &entropy_src_, kDifEntropySrcIrqEsEntropyValid, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(ENTROPY_SRC_INTR_STATE_REG_OFFSET, - {{ENTROPY_SRC_INTR_STATE_ES_FATAL_ERR_BIT, false}}); - EXPECT_DIF_OK(dif_entropy_src_irq_is_pending( - &entropy_src_, kDifEntropySrcIrqEsFatalErr, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 4; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_entropy_src_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(ENTROPY_SRC_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_entropy_src_irq_acknowledge_all(&entropy_src_)); -} - -class IrqAcknowledgeTest : public EntropySrcTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG(dif_entropy_src_irq_acknowledge( - nullptr, kDifEntropySrcIrqEsEntropyValid)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG(dif_entropy_src_irq_acknowledge( - nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(ENTROPY_SRC_INTR_STATE_REG_OFFSET, - {{ENTROPY_SRC_INTR_STATE_ES_ENTROPY_VALID_BIT, true}}); - EXPECT_DIF_OK(dif_entropy_src_irq_acknowledge( - &entropy_src_, kDifEntropySrcIrqEsEntropyValid)); - - // Clear the last IRQ state. - EXPECT_WRITE32(ENTROPY_SRC_INTR_STATE_REG_OFFSET, - {{ENTROPY_SRC_INTR_STATE_ES_FATAL_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_entropy_src_irq_acknowledge(&entropy_src_, - kDifEntropySrcIrqEsFatalErr)); -} - -class IrqForceTest : public EntropySrcTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_entropy_src_irq_force( - nullptr, kDifEntropySrcIrqEsEntropyValid, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG(dif_entropy_src_irq_force( - nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(ENTROPY_SRC_INTR_TEST_REG_OFFSET, - {{ENTROPY_SRC_INTR_TEST_ES_ENTROPY_VALID_BIT, true}}); - EXPECT_DIF_OK(dif_entropy_src_irq_force( - &entropy_src_, kDifEntropySrcIrqEsEntropyValid, true)); - - // Force last IRQ. - EXPECT_WRITE32(ENTROPY_SRC_INTR_TEST_REG_OFFSET, - {{ENTROPY_SRC_INTR_TEST_ES_FATAL_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_entropy_src_irq_force(&entropy_src_, - kDifEntropySrcIrqEsFatalErr, true)); -} - -class IrqGetEnabledTest : public EntropySrcTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_entropy_src_irq_get_enabled( - nullptr, kDifEntropySrcIrqEsEntropyValid, &irq_state)); - - EXPECT_DIF_BADARG(dif_entropy_src_irq_get_enabled( - &entropy_src_, kDifEntropySrcIrqEsEntropyValid, nullptr)); - - EXPECT_DIF_BADARG(dif_entropy_src_irq_get_enabled( - nullptr, kDifEntropySrcIrqEsEntropyValid, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_entropy_src_irq_get_enabled( - &entropy_src_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(ENTROPY_SRC_INTR_ENABLE_REG_OFFSET, - {{ENTROPY_SRC_INTR_ENABLE_ES_ENTROPY_VALID_BIT, true}}); - EXPECT_DIF_OK(dif_entropy_src_irq_get_enabled( - &entropy_src_, kDifEntropySrcIrqEsEntropyValid, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(ENTROPY_SRC_INTR_ENABLE_REG_OFFSET, - {{ENTROPY_SRC_INTR_ENABLE_ES_FATAL_ERR_BIT, false}}); - EXPECT_DIF_OK(dif_entropy_src_irq_get_enabled( - &entropy_src_, kDifEntropySrcIrqEsFatalErr, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public EntropySrcTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_entropy_src_irq_set_enabled( - nullptr, kDifEntropySrcIrqEsEntropyValid, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_entropy_src_irq_set_enabled( - &entropy_src_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(ENTROPY_SRC_INTR_ENABLE_REG_OFFSET, - {{ENTROPY_SRC_INTR_ENABLE_ES_ENTROPY_VALID_BIT, 0x1, true}}); - EXPECT_DIF_OK(dif_entropy_src_irq_set_enabled( - &entropy_src_, kDifEntropySrcIrqEsEntropyValid, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(ENTROPY_SRC_INTR_ENABLE_REG_OFFSET, - {{ENTROPY_SRC_INTR_ENABLE_ES_FATAL_ERR_BIT, 0x1, false}}); - EXPECT_DIF_OK(dif_entropy_src_irq_set_enabled( - &entropy_src_, kDifEntropySrcIrqEsFatalErr, irq_state)); -} - -class IrqDisableAllTest : public EntropySrcTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_entropy_src_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_entropy_src_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_entropy_src_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(ENTROPY_SRC_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_entropy_src_irq_disable_all(&entropy_src_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_entropy_src_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(ENTROPY_SRC_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(ENTROPY_SRC_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_entropy_src_irq_disable_all(&entropy_src_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_entropy_src_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(ENTROPY_SRC_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(ENTROPY_SRC_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_entropy_src_irq_disable_all(&entropy_src_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public EntropySrcTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_entropy_src_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_entropy_src_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_entropy_src_irq_restore_all(&entropy_src_, nullptr)); - - EXPECT_DIF_BADARG(dif_entropy_src_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_entropy_src_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(ENTROPY_SRC_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_entropy_src_irq_restore_all(&entropy_src_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_entropy_src_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(ENTROPY_SRC_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_entropy_src_irq_restore_all(&entropy_src_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_entropy_src_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen.c b/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen.c deleted file mode 100644 index af72e8b4cf4fe..0000000000000 --- a/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen.c +++ /dev/null @@ -1,298 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_flash_ctrl_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "flash_ctrl_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_init(mmio_region_t base_addr, - dif_flash_ctrl_t *flash_ctrl) { - if (flash_ctrl == NULL) { - return kDifBadArg; - } - - flash_ctrl->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_flash_ctrl_alert_force(const dif_flash_ctrl_t *flash_ctrl, - dif_flash_ctrl_alert_t alert) { - if (flash_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifFlashCtrlAlertRecovErr: - alert_idx = FLASH_CTRL_ALERT_TEST_RECOV_ERR_BIT; - break; - case kDifFlashCtrlAlertFatalStdErr: - alert_idx = FLASH_CTRL_ALERT_TEST_FATAL_STD_ERR_BIT; - break; - case kDifFlashCtrlAlertFatalErr: - alert_idx = FLASH_CTRL_ALERT_TEST_FATAL_ERR_BIT; - break; - case kDifFlashCtrlAlertFatalPrimFlashAlert: - alert_idx = FLASH_CTRL_ALERT_TEST_FATAL_PRIM_FLASH_ALERT_BIT; - break; - case kDifFlashCtrlAlertRecovPrimFlashAlert: - alert_idx = FLASH_CTRL_ALERT_TEST_RECOV_PRIM_FLASH_ALERT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(flash_ctrl->base_addr, - (ptrdiff_t)FLASH_CTRL_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool flash_ctrl_get_irq_bit_index(dif_flash_ctrl_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifFlashCtrlIrqProgEmpty: - *index_out = FLASH_CTRL_INTR_COMMON_PROG_EMPTY_BIT; - break; - case kDifFlashCtrlIrqProgLvl: - *index_out = FLASH_CTRL_INTR_COMMON_PROG_LVL_BIT; - break; - case kDifFlashCtrlIrqRdFull: - *index_out = FLASH_CTRL_INTR_COMMON_RD_FULL_BIT; - break; - case kDifFlashCtrlIrqRdLvl: - *index_out = FLASH_CTRL_INTR_COMMON_RD_LVL_BIT; - break; - case kDifFlashCtrlIrqOpDone: - *index_out = FLASH_CTRL_INTR_COMMON_OP_DONE_BIT; - break; - case kDifFlashCtrlIrqCorrErr: - *index_out = FLASH_CTRL_INTR_COMMON_CORR_ERR_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeStatus, kDifIrqTypeStatus, kDifIrqTypeStatus, - kDifIrqTypeStatus, kDifIrqTypeEvent, kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_get_type(const dif_flash_ctrl_t *flash_ctrl, - dif_flash_ctrl_irq_t irq, - dif_irq_type_t *type) { - if (flash_ctrl == NULL || type == NULL || irq < 0 || - irq > kDifFlashCtrlIrqCorrErr) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_get_state( - const dif_flash_ctrl_t *flash_ctrl, - dif_flash_ctrl_irq_state_snapshot_t *snapshot) { - if (flash_ctrl == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(flash_ctrl->base_addr, - (ptrdiff_t)FLASH_CTRL_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, - (ptrdiff_t)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) { - if (flash_ctrl == NULL || is_pending == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!flash_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - flash_ctrl->base_addr, (ptrdiff_t)FLASH_CTRL_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_acknowledge_all( - const dif_flash_ctrl_t *flash_ctrl) { - if (flash_ctrl == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(flash_ctrl->base_addr, - (ptrdiff_t)FLASH_CTRL_INTR_STATE_REG_OFFSET, UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_acknowledge(const dif_flash_ctrl_t *flash_ctrl, - dif_flash_ctrl_irq_t irq) { - if (flash_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!flash_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(flash_ctrl->base_addr, - (ptrdiff_t)FLASH_CTRL_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_force(const dif_flash_ctrl_t *flash_ctrl, - dif_flash_ctrl_irq_t irq, - const bool val) { - if (flash_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!flash_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(flash_ctrl->base_addr, - (ptrdiff_t)FLASH_CTRL_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_get_enabled(const dif_flash_ctrl_t *flash_ctrl, - dif_flash_ctrl_irq_t irq, - dif_toggle_t *state) { - if (flash_ctrl == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!flash_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - flash_ctrl->base_addr, (ptrdiff_t)FLASH_CTRL_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_set_enabled(const dif_flash_ctrl_t *flash_ctrl, - dif_flash_ctrl_irq_t irq, - dif_toggle_t state) { - if (flash_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!flash_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - flash_ctrl->base_addr, (ptrdiff_t)FLASH_CTRL_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(flash_ctrl->base_addr, - (ptrdiff_t)FLASH_CTRL_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_disable_all( - const dif_flash_ctrl_t *flash_ctrl, - dif_flash_ctrl_irq_enable_snapshot_t *snapshot) { - if (flash_ctrl == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32( - flash_ctrl->base_addr, (ptrdiff_t)FLASH_CTRL_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(flash_ctrl->base_addr, - (ptrdiff_t)FLASH_CTRL_INTR_ENABLE_REG_OFFSET, 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_restore_all( - const dif_flash_ctrl_t *flash_ctrl, - const dif_flash_ctrl_irq_enable_snapshot_t *snapshot) { - if (flash_ctrl == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(flash_ctrl->base_addr, - (ptrdiff_t)FLASH_CTRL_INTR_ENABLE_REG_OFFSET, *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen.h b/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen.h deleted file mode 100644 index beb70dda903bc..0000000000000 --- a/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen.h +++ /dev/null @@ -1,289 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_FLASH_CTRL_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_FLASH_CTRL_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief FLASH_CTRL Device Interface - * Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to flash_ctrl. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_flash_ctrl { - /** - * The base address for the flash_ctrl hardware registers. - */ - mmio_region_t base_addr; -} dif_flash_ctrl_t; - -/** - * Creates a new handle for a(n) flash_ctrl peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the flash_ctrl peripheral. - * @param[out] flash_ctrl Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_init(mmio_region_t base_addr, - dif_flash_ctrl_t *flash_ctrl); - -/** - * A flash_ctrl alert type. - */ -typedef enum dif_flash_ctrl_alert { - /** - * Flash recoverable errors - */ - kDifFlashCtrlAlertRecovErr = 0, - /** - * Flash standard fatal errors - */ - kDifFlashCtrlAlertFatalStdErr = 1, - /** - * Flash fatal errors including uncorrectable ECC errors. Note that this - * alert is not always fatal. The underlying error bits in the !!FAULT_STATUS - * register remain set until reset, meaning the alert keeps firing. This - * doesn't hold for !!FAULT_STATUS.PHY_RELBL_ERR and - * !!FAULT_STATUS.PHY_STORAGE_ERR. To enable firmware dealing with multi-bit - * ECC and ICV errors during firmware selection and verification, these error - * bits can be cleared. After passing this stage, it is recommended that - * firmware classifies the corresponding alert as fatal on the receiver end, - * i.e, inside the alert handler. - */ - kDifFlashCtrlAlertFatalErr = 2, - /** - * Fatal alert triggered inside the flash primitive, including fatal TL-UL bus - * integrity faults of the test interface. - */ - kDifFlashCtrlAlertFatalPrimFlashAlert = 3, - /** - * Recoverable alert triggered inside the flash primitive. - */ - kDifFlashCtrlAlertRecovPrimFlashAlert = 4, -} dif_flash_ctrl_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param flash_ctrl A flash_ctrl handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_alert_force(const dif_flash_ctrl_t *flash_ctrl, - dif_flash_ctrl_alert_t alert); - -/** - * A flash_ctrl interrupt request type. - */ -typedef enum dif_flash_ctrl_irq { - /** - * Program FIFO empty - */ - kDifFlashCtrlIrqProgEmpty = 0, - /** - * Program FIFO drained to level - */ - kDifFlashCtrlIrqProgLvl = 1, - /** - * Read FIFO full - */ - kDifFlashCtrlIrqRdFull = 2, - /** - * Read FIFO filled to level - */ - kDifFlashCtrlIrqRdLvl = 3, - /** - * Operation complete - */ - kDifFlashCtrlIrqOpDone = 4, - /** - * Correctable error encountered - */ - kDifFlashCtrlIrqCorrErr = 5, -} dif_flash_ctrl_irq_t; - -/** - * 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()` - * and `dif_flash_ctrl_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_flash_ctrl_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param flash_ctrl A flash_ctrl handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_get_type(const dif_flash_ctrl_t *flash_ctrl, - dif_flash_ctrl_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param flash_ctrl A flash_ctrl handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_get_state( - const dif_flash_ctrl_t *flash_ctrl, - dif_flash_ctrl_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param flash_ctrl A flash_ctrl handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param flash_ctrl A flash_ctrl handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_acknowledge_all( - const dif_flash_ctrl_t *flash_ctrl); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param flash_ctrl A flash_ctrl handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_acknowledge(const dif_flash_ctrl_t *flash_ctrl, - dif_flash_ctrl_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param flash_ctrl A flash_ctrl handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_force(const dif_flash_ctrl_t *flash_ctrl, - dif_flash_ctrl_irq_t irq, const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_flash_ctrl_irq_disable_all()` and `dif_flash_ctrl_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_flash_ctrl_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param flash_ctrl A flash_ctrl handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_get_enabled(const dif_flash_ctrl_t *flash_ctrl, - dif_flash_ctrl_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param flash_ctrl A flash_ctrl handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_set_enabled(const dif_flash_ctrl_t *flash_ctrl, - dif_flash_ctrl_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param flash_ctrl A flash_ctrl handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_disable_all( - const dif_flash_ctrl_t *flash_ctrl, - dif_flash_ctrl_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param flash_ctrl A flash_ctrl handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_flash_ctrl_irq_restore_all( - const dif_flash_ctrl_t *flash_ctrl, - const dif_flash_ctrl_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_FLASH_CTRL_AUTOGEN_H_ 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 deleted file mode 100644 index bce2be2216137..0000000000000 --- a/sw/device/lib/dif/autogen/dif_flash_ctrl_autogen_unittest.cc +++ /dev/null @@ -1,402 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_flash_ctrl_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "flash_ctrl_regs.h" // Generated. - -namespace dif_flash_ctrl_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class FlashCtrlTest : public Test, public MmioTest { - protected: - dif_flash_ctrl_t flash_ctrl_ = {.base_addr = dev().region()}; -}; - -class InitTest : public FlashCtrlTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_flash_ctrl_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_flash_ctrl_init(dev().region(), &flash_ctrl_)); -} - -class AlertForceTest : public FlashCtrlTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_flash_ctrl_alert_force(nullptr, kDifFlashCtrlAlertRecovErr)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG(dif_flash_ctrl_alert_force( - nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(FLASH_CTRL_ALERT_TEST_REG_OFFSET, - {{FLASH_CTRL_ALERT_TEST_RECOV_ERR_BIT, true}}); - EXPECT_DIF_OK( - dif_flash_ctrl_alert_force(&flash_ctrl_, kDifFlashCtrlAlertRecovErr)); - - // Force last alert. - EXPECT_WRITE32(FLASH_CTRL_ALERT_TEST_REG_OFFSET, - {{FLASH_CTRL_ALERT_TEST_RECOV_PRIM_FLASH_ALERT_BIT, true}}); - EXPECT_DIF_OK(dif_flash_ctrl_alert_force( - &flash_ctrl_, kDifFlashCtrlAlertRecovPrimFlashAlert)); -} - -class IrqGetTypeTest : public FlashCtrlTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG( - dif_flash_ctrl_irq_get_type(nullptr, kDifFlashCtrlIrqProgEmpty, &type)); - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_get_type( - &flash_ctrl_, kDifFlashCtrlIrqProgEmpty, nullptr)); - - EXPECT_DIF_BADARG( - dif_flash_ctrl_irq_get_type(nullptr, kDifFlashCtrlIrqProgEmpty, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_get_type( - &flash_ctrl_, - static_cast(kDifFlashCtrlIrqCorrErr + 1), &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_flash_ctrl_irq_get_type(&flash_ctrl_, - kDifFlashCtrlIrqProgEmpty, &type)); - EXPECT_EQ(type, kDifIrqTypeStatus); -} - -class IrqGetStateTest : public FlashCtrlTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_flash_ctrl_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_get_state(&flash_ctrl_, nullptr)); - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_flash_ctrl_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(FLASH_CTRL_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_flash_ctrl_irq_get_state(&flash_ctrl_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public FlashCtrlTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_is_pending( - nullptr, kDifFlashCtrlIrqProgEmpty, &is_pending)); - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_is_pending( - &flash_ctrl_, kDifFlashCtrlIrqProgEmpty, nullptr)); - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_is_pending( - nullptr, kDifFlashCtrlIrqProgEmpty, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_is_pending( - &flash_ctrl_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(FLASH_CTRL_INTR_STATE_REG_OFFSET, - {{FLASH_CTRL_INTR_STATE_PROG_EMPTY_BIT, true}}); - EXPECT_DIF_OK(dif_flash_ctrl_irq_is_pending( - &flash_ctrl_, kDifFlashCtrlIrqProgEmpty, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(FLASH_CTRL_INTR_STATE_REG_OFFSET, - {{FLASH_CTRL_INTR_STATE_CORR_ERR_BIT, false}}); - EXPECT_DIF_OK(dif_flash_ctrl_irq_is_pending( - &flash_ctrl_, kDifFlashCtrlIrqCorrErr, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 6; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(FLASH_CTRL_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_flash_ctrl_irq_acknowledge_all(&flash_ctrl_)); -} - -class IrqAcknowledgeTest : public FlashCtrlTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_flash_ctrl_irq_acknowledge(nullptr, kDifFlashCtrlIrqProgEmpty)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_acknowledge( - nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(FLASH_CTRL_INTR_STATE_REG_OFFSET, - {{FLASH_CTRL_INTR_STATE_PROG_EMPTY_BIT, true}}); - EXPECT_DIF_OK( - dif_flash_ctrl_irq_acknowledge(&flash_ctrl_, kDifFlashCtrlIrqProgEmpty)); - - // Clear the last IRQ state. - EXPECT_WRITE32(FLASH_CTRL_INTR_STATE_REG_OFFSET, - {{FLASH_CTRL_INTR_STATE_CORR_ERR_BIT, true}}); - EXPECT_DIF_OK( - dif_flash_ctrl_irq_acknowledge(&flash_ctrl_, kDifFlashCtrlIrqCorrErr)); -} - -class IrqForceTest : public FlashCtrlTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_flash_ctrl_irq_force(nullptr, kDifFlashCtrlIrqProgEmpty, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_force( - nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(FLASH_CTRL_INTR_TEST_REG_OFFSET, - {{FLASH_CTRL_INTR_TEST_PROG_EMPTY_BIT, true}}); - EXPECT_DIF_OK( - dif_flash_ctrl_irq_force(&flash_ctrl_, kDifFlashCtrlIrqProgEmpty, true)); - - // Force last IRQ. - EXPECT_WRITE32(FLASH_CTRL_INTR_TEST_REG_OFFSET, - {{FLASH_CTRL_INTR_TEST_CORR_ERR_BIT, true}}); - EXPECT_DIF_OK( - dif_flash_ctrl_irq_force(&flash_ctrl_, kDifFlashCtrlIrqCorrErr, true)); -} - -class IrqGetEnabledTest : public FlashCtrlTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_get_enabled( - nullptr, kDifFlashCtrlIrqProgEmpty, &irq_state)); - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_get_enabled( - &flash_ctrl_, kDifFlashCtrlIrqProgEmpty, nullptr)); - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_get_enabled( - nullptr, kDifFlashCtrlIrqProgEmpty, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_get_enabled( - &flash_ctrl_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(FLASH_CTRL_INTR_ENABLE_REG_OFFSET, - {{FLASH_CTRL_INTR_ENABLE_PROG_EMPTY_BIT, true}}); - EXPECT_DIF_OK(dif_flash_ctrl_irq_get_enabled( - &flash_ctrl_, kDifFlashCtrlIrqProgEmpty, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(FLASH_CTRL_INTR_ENABLE_REG_OFFSET, - {{FLASH_CTRL_INTR_ENABLE_CORR_ERR_BIT, false}}); - EXPECT_DIF_OK(dif_flash_ctrl_irq_get_enabled( - &flash_ctrl_, kDifFlashCtrlIrqCorrErr, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public FlashCtrlTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_set_enabled( - nullptr, kDifFlashCtrlIrqProgEmpty, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_set_enabled( - &flash_ctrl_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(FLASH_CTRL_INTR_ENABLE_REG_OFFSET, - {{FLASH_CTRL_INTR_ENABLE_PROG_EMPTY_BIT, 0x1, true}}); - EXPECT_DIF_OK(dif_flash_ctrl_irq_set_enabled( - &flash_ctrl_, kDifFlashCtrlIrqProgEmpty, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(FLASH_CTRL_INTR_ENABLE_REG_OFFSET, - {{FLASH_CTRL_INTR_ENABLE_CORR_ERR_BIT, 0x1, false}}); - EXPECT_DIF_OK(dif_flash_ctrl_irq_set_enabled( - &flash_ctrl_, kDifFlashCtrlIrqCorrErr, irq_state)); -} - -class IrqDisableAllTest : public FlashCtrlTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_flash_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(FLASH_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_flash_ctrl_irq_disable_all(&flash_ctrl_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_flash_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(FLASH_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(FLASH_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_flash_ctrl_irq_disable_all(&flash_ctrl_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_flash_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(FLASH_CTRL_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(FLASH_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_flash_ctrl_irq_disable_all(&flash_ctrl_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public FlashCtrlTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_flash_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_restore_all(&flash_ctrl_, nullptr)); - - EXPECT_DIF_BADARG(dif_flash_ctrl_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_flash_ctrl_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(FLASH_CTRL_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_flash_ctrl_irq_restore_all(&flash_ctrl_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_flash_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(FLASH_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_flash_ctrl_irq_restore_all(&flash_ctrl_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_flash_ctrl_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_gpio_autogen.c b/sw/device/lib/dif/autogen/dif_gpio_autogen.c deleted file mode 100644 index 50f99f32816e7..0000000000000 --- a/sw/device/lib/dif/autogen/dif_gpio_autogen.c +++ /dev/null @@ -1,354 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_gpio_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "gpio_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_init(mmio_region_t base_addr, dif_gpio_t *gpio) { - if (gpio == NULL) { - return kDifBadArg; - } - - gpio->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_gpio_alert_force(const dif_gpio_t *gpio, - dif_gpio_alert_t alert) { - if (gpio == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifGpioAlertFatalFault: - alert_idx = GPIO_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(gpio->base_addr, (ptrdiff_t)GPIO_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool gpio_get_irq_bit_index(dif_gpio_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifGpioIrqGpio0: - *index_out = 0; - break; - case kDifGpioIrqGpio1: - *index_out = 1; - break; - case kDifGpioIrqGpio2: - *index_out = 2; - break; - case kDifGpioIrqGpio3: - *index_out = 3; - break; - case kDifGpioIrqGpio4: - *index_out = 4; - break; - case kDifGpioIrqGpio5: - *index_out = 5; - break; - case kDifGpioIrqGpio6: - *index_out = 6; - break; - case kDifGpioIrqGpio7: - *index_out = 7; - break; - case kDifGpioIrqGpio8: - *index_out = 8; - break; - case kDifGpioIrqGpio9: - *index_out = 9; - break; - case kDifGpioIrqGpio10: - *index_out = 10; - break; - case kDifGpioIrqGpio11: - *index_out = 11; - break; - case kDifGpioIrqGpio12: - *index_out = 12; - break; - case kDifGpioIrqGpio13: - *index_out = 13; - break; - case kDifGpioIrqGpio14: - *index_out = 14; - break; - case kDifGpioIrqGpio15: - *index_out = 15; - break; - case kDifGpioIrqGpio16: - *index_out = 16; - break; - case kDifGpioIrqGpio17: - *index_out = 17; - break; - case kDifGpioIrqGpio18: - *index_out = 18; - break; - case kDifGpioIrqGpio19: - *index_out = 19; - break; - case kDifGpioIrqGpio20: - *index_out = 20; - break; - case kDifGpioIrqGpio21: - *index_out = 21; - break; - case kDifGpioIrqGpio22: - *index_out = 22; - break; - case kDifGpioIrqGpio23: - *index_out = 23; - break; - case kDifGpioIrqGpio24: - *index_out = 24; - break; - case kDifGpioIrqGpio25: - *index_out = 25; - break; - case kDifGpioIrqGpio26: - *index_out = 26; - break; - case kDifGpioIrqGpio27: - *index_out = 27; - break; - case kDifGpioIrqGpio28: - *index_out = 28; - break; - case kDifGpioIrqGpio29: - *index_out = 29; - break; - case kDifGpioIrqGpio30: - *index_out = 30; - break; - case kDifGpioIrqGpio31: - *index_out = 31; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, - kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, - kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, - kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, - kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, - kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, - kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, - kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_get_type(const dif_gpio_t *gpio, dif_gpio_irq_t irq, - dif_irq_type_t *type) { - if (gpio == NULL || type == NULL || irq < 0 || irq > kDifGpioIrqGpio31) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_get_state(const dif_gpio_t *gpio, - dif_gpio_irq_state_snapshot_t *snapshot) { - if (gpio == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(gpio->base_addr, - (ptrdiff_t)GPIO_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, (ptrdiff_t)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) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!gpio_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - gpio->base_addr, (ptrdiff_t)GPIO_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_acknowledge_all(const dif_gpio_t *gpio) { - if (gpio == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(gpio->base_addr, (ptrdiff_t)GPIO_INTR_STATE_REG_OFFSET, - UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_acknowledge(const dif_gpio_t *gpio, - dif_gpio_irq_t irq) { - if (gpio == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!gpio_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(gpio->base_addr, (ptrdiff_t)GPIO_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_force(const dif_gpio_t *gpio, dif_gpio_irq_t irq, - const bool val) { - if (gpio == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!gpio_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(gpio->base_addr, (ptrdiff_t)GPIO_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_get_enabled(const dif_gpio_t *gpio, - dif_gpio_irq_t irq, dif_toggle_t *state) { - if (gpio == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!gpio_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - gpio->base_addr, (ptrdiff_t)GPIO_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_set_enabled(const dif_gpio_t *gpio, - dif_gpio_irq_t irq, dif_toggle_t state) { - if (gpio == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!gpio_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - gpio->base_addr, (ptrdiff_t)GPIO_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(gpio->base_addr, (ptrdiff_t)GPIO_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_disable_all( - const dif_gpio_t *gpio, dif_gpio_irq_enable_snapshot_t *snapshot) { - if (gpio == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(gpio->base_addr, - (ptrdiff_t)GPIO_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(gpio->base_addr, (ptrdiff_t)GPIO_INTR_ENABLE_REG_OFFSET, - 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_restore_all( - const dif_gpio_t *gpio, const dif_gpio_irq_enable_snapshot_t *snapshot) { - if (gpio == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(gpio->base_addr, (ptrdiff_t)GPIO_INTR_ENABLE_REG_OFFSET, - *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_gpio_autogen.h b/sw/device/lib/dif/autogen/dif_gpio_autogen.h deleted file mode 100644 index 2e3d1a2265072..0000000000000 --- a/sw/device/lib/dif/autogen/dif_gpio_autogen.h +++ /dev/null @@ -1,265 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_GPIO_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_GPIO_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief GPIO Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to gpio. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_gpio { - /** - * The base address for the gpio hardware registers. - */ - mmio_region_t base_addr; -} dif_gpio_t; - -/** - * Creates a new handle for a(n) gpio peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the gpio peripheral. - * @param[out] gpio Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_init(mmio_region_t base_addr, dif_gpio_t *gpio); - -/** - * A gpio alert type. - */ -typedef enum dif_gpio_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifGpioAlertFatalFault = 0, -} dif_gpio_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param gpio A gpio handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_alert_force(const dif_gpio_t *gpio, - dif_gpio_alert_t alert); - -/** - * A gpio interrupt request type. - */ -typedef enum dif_gpio_irq { - /** - * Raised if any of GPIO pin detects configured interrupt mode - */ - kDifGpioIrqGpio0 = 0, - kDifGpioIrqGpio1 = 1, - kDifGpioIrqGpio2 = 2, - kDifGpioIrqGpio3 = 3, - kDifGpioIrqGpio4 = 4, - kDifGpioIrqGpio5 = 5, - kDifGpioIrqGpio6 = 6, - kDifGpioIrqGpio7 = 7, - kDifGpioIrqGpio8 = 8, - kDifGpioIrqGpio9 = 9, - kDifGpioIrqGpio10 = 10, - kDifGpioIrqGpio11 = 11, - kDifGpioIrqGpio12 = 12, - kDifGpioIrqGpio13 = 13, - kDifGpioIrqGpio14 = 14, - kDifGpioIrqGpio15 = 15, - kDifGpioIrqGpio16 = 16, - kDifGpioIrqGpio17 = 17, - kDifGpioIrqGpio18 = 18, - kDifGpioIrqGpio19 = 19, - kDifGpioIrqGpio20 = 20, - kDifGpioIrqGpio21 = 21, - kDifGpioIrqGpio22 = 22, - kDifGpioIrqGpio23 = 23, - kDifGpioIrqGpio24 = 24, - kDifGpioIrqGpio25 = 25, - kDifGpioIrqGpio26 = 26, - kDifGpioIrqGpio27 = 27, - kDifGpioIrqGpio28 = 28, - kDifGpioIrqGpio29 = 29, - kDifGpioIrqGpio30 = 30, - kDifGpioIrqGpio31 = 31, -} dif_gpio_irq_t; - -/** - * 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()` - * and `dif_gpio_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_gpio_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param gpio A gpio handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_get_type(const dif_gpio_t *gpio, dif_gpio_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param gpio A gpio handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_get_state(const dif_gpio_t *gpio, - dif_gpio_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param gpio A gpio handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param gpio A gpio handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_acknowledge_all(const dif_gpio_t *gpio); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param gpio A gpio handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_acknowledge(const dif_gpio_t *gpio, - dif_gpio_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param gpio A gpio handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_force(const dif_gpio_t *gpio, dif_gpio_irq_t irq, - const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_gpio_irq_disable_all()` and `dif_gpio_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_gpio_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param gpio A gpio handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_get_enabled(const dif_gpio_t *gpio, - dif_gpio_irq_t irq, dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param gpio A gpio handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_set_enabled(const dif_gpio_t *gpio, - dif_gpio_irq_t irq, dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param gpio A gpio handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_disable_all(const dif_gpio_t *gpio, - dif_gpio_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param gpio A gpio handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_gpio_irq_restore_all( - const dif_gpio_t *gpio, const dif_gpio_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_GPIO_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_gpio_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_gpio_autogen_unittest.cc deleted file mode 100644 index 256f65f2e6fad..0000000000000 --- a/sw/device/lib/dif/autogen/dif_gpio_autogen_unittest.cc +++ /dev/null @@ -1,365 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_gpio_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "gpio_regs.h" // Generated. - -namespace dif_gpio_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class GpioTest : public Test, public MmioTest { - protected: - dif_gpio_t gpio_ = {.base_addr = dev().region()}; -}; - -class InitTest : public GpioTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_gpio_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_gpio_init(dev().region(), &gpio_)); -} - -class AlertForceTest : public GpioTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_gpio_alert_force(nullptr, kDifGpioAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_gpio_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(GPIO_ALERT_TEST_REG_OFFSET, - {{GPIO_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_gpio_alert_force(&gpio_, kDifGpioAlertFatalFault)); -} - -class IrqGetTypeTest : public GpioTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_gpio_irq_get_type(nullptr, kDifGpioIrqGpio0, &type)); - - EXPECT_DIF_BADARG(dif_gpio_irq_get_type(&gpio_, kDifGpioIrqGpio0, nullptr)); - - EXPECT_DIF_BADARG(dif_gpio_irq_get_type(nullptr, kDifGpioIrqGpio0, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_gpio_irq_get_type( - &gpio_, static_cast(kDifGpioIrqGpio31 + 1), &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_gpio_irq_get_type(&gpio_, kDifGpioIrqGpio0, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public GpioTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_gpio_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_gpio_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_gpio_irq_get_state(&gpio_, nullptr)); - - EXPECT_DIF_BADARG(dif_gpio_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_gpio_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(GPIO_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_gpio_irq_get_state(&gpio_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public GpioTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG( - dif_gpio_irq_is_pending(nullptr, kDifGpioIrqGpio0, &is_pending)); - - EXPECT_DIF_BADARG(dif_gpio_irq_is_pending(&gpio_, kDifGpioIrqGpio0, nullptr)); - - EXPECT_DIF_BADARG( - dif_gpio_irq_is_pending(nullptr, kDifGpioIrqGpio0, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_gpio_irq_is_pending( - &gpio_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(GPIO_INTR_STATE_REG_OFFSET, {{0, true}}); - EXPECT_DIF_OK(dif_gpio_irq_is_pending(&gpio_, kDifGpioIrqGpio0, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(GPIO_INTR_STATE_REG_OFFSET, {{31, false}}); - EXPECT_DIF_OK(dif_gpio_irq_is_pending(&gpio_, kDifGpioIrqGpio31, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 32; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_gpio_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(GPIO_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_gpio_irq_acknowledge_all(&gpio_)); -} - -class IrqAcknowledgeTest : public GpioTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG(dif_gpio_irq_acknowledge(nullptr, kDifGpioIrqGpio0)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_gpio_irq_acknowledge(nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(GPIO_INTR_STATE_REG_OFFSET, {{0, true}}); - EXPECT_DIF_OK(dif_gpio_irq_acknowledge(&gpio_, kDifGpioIrqGpio0)); - - // Clear the last IRQ state. - EXPECT_WRITE32(GPIO_INTR_STATE_REG_OFFSET, {{31, true}}); - EXPECT_DIF_OK(dif_gpio_irq_acknowledge(&gpio_, kDifGpioIrqGpio31)); -} - -class IrqForceTest : public GpioTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_gpio_irq_force(nullptr, kDifGpioIrqGpio0, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_gpio_irq_force(nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(GPIO_INTR_TEST_REG_OFFSET, {{0, true}}); - EXPECT_DIF_OK(dif_gpio_irq_force(&gpio_, kDifGpioIrqGpio0, true)); - - // Force last IRQ. - EXPECT_WRITE32(GPIO_INTR_TEST_REG_OFFSET, {{31, true}}); - EXPECT_DIF_OK(dif_gpio_irq_force(&gpio_, kDifGpioIrqGpio31, true)); -} - -class IrqGetEnabledTest : public GpioTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG( - dif_gpio_irq_get_enabled(nullptr, kDifGpioIrqGpio0, &irq_state)); - - EXPECT_DIF_BADARG( - dif_gpio_irq_get_enabled(&gpio_, kDifGpioIrqGpio0, nullptr)); - - EXPECT_DIF_BADARG( - dif_gpio_irq_get_enabled(nullptr, kDifGpioIrqGpio0, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_gpio_irq_get_enabled( - &gpio_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(GPIO_INTR_ENABLE_REG_OFFSET, {{0, true}}); - EXPECT_DIF_OK(dif_gpio_irq_get_enabled(&gpio_, kDifGpioIrqGpio0, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(GPIO_INTR_ENABLE_REG_OFFSET, {{31, false}}); - EXPECT_DIF_OK( - dif_gpio_irq_get_enabled(&gpio_, kDifGpioIrqGpio31, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public GpioTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG( - dif_gpio_irq_set_enabled(nullptr, kDifGpioIrqGpio0, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_gpio_irq_set_enabled( - &gpio_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(GPIO_INTR_ENABLE_REG_OFFSET, {{0, 0x1, true}}); - EXPECT_DIF_OK(dif_gpio_irq_set_enabled(&gpio_, kDifGpioIrqGpio0, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(GPIO_INTR_ENABLE_REG_OFFSET, {{31, 0x1, false}}); - EXPECT_DIF_OK(dif_gpio_irq_set_enabled(&gpio_, kDifGpioIrqGpio31, irq_state)); -} - -class IrqDisableAllTest : public GpioTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_gpio_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_gpio_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_gpio_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(GPIO_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_gpio_irq_disable_all(&gpio_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_gpio_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(GPIO_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(GPIO_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_gpio_irq_disable_all(&gpio_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_gpio_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(GPIO_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(GPIO_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_gpio_irq_disable_all(&gpio_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public GpioTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_gpio_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_gpio_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_gpio_irq_restore_all(&gpio_, nullptr)); - - EXPECT_DIF_BADARG(dif_gpio_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_gpio_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(GPIO_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_gpio_irq_restore_all(&gpio_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_gpio_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(GPIO_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_gpio_irq_restore_all(&gpio_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_gpio_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_hmac_autogen.c b/sw/device/lib/dif/autogen/dif_hmac_autogen.c deleted file mode 100644 index c41fb6a606610..0000000000000 --- a/sw/device/lib/dif/autogen/dif_hmac_autogen.c +++ /dev/null @@ -1,262 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_hmac_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "hmac_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_init(mmio_region_t base_addr, dif_hmac_t *hmac) { - if (hmac == NULL) { - return kDifBadArg; - } - - hmac->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_hmac_alert_force(const dif_hmac_t *hmac, - dif_hmac_alert_t alert) { - if (hmac == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifHmacAlertFatalFault: - alert_idx = HMAC_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(hmac->base_addr, (ptrdiff_t)HMAC_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool hmac_get_irq_bit_index(dif_hmac_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifHmacIrqHmacDone: - *index_out = HMAC_INTR_COMMON_HMAC_DONE_BIT; - break; - case kDifHmacIrqFifoEmpty: - *index_out = HMAC_INTR_COMMON_FIFO_EMPTY_BIT; - break; - case kDifHmacIrqHmacErr: - *index_out = HMAC_INTR_COMMON_HMAC_ERR_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, - kDifIrqTypeStatus, - kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_get_type(const dif_hmac_t *hmac, dif_hmac_irq_t irq, - dif_irq_type_t *type) { - if (hmac == NULL || type == NULL || irq < 0 || irq > kDifHmacIrqHmacErr) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_get_state(const dif_hmac_t *hmac, - dif_hmac_irq_state_snapshot_t *snapshot) { - if (hmac == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(hmac->base_addr, - (ptrdiff_t)HMAC_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, (ptrdiff_t)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) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!hmac_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - hmac->base_addr, (ptrdiff_t)HMAC_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_acknowledge_all(const dif_hmac_t *hmac) { - if (hmac == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(hmac->base_addr, (ptrdiff_t)HMAC_INTR_STATE_REG_OFFSET, - UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_acknowledge(const dif_hmac_t *hmac, - dif_hmac_irq_t irq) { - if (hmac == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!hmac_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(hmac->base_addr, (ptrdiff_t)HMAC_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_force(const dif_hmac_t *hmac, dif_hmac_irq_t irq, - const bool val) { - if (hmac == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!hmac_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(hmac->base_addr, (ptrdiff_t)HMAC_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_get_enabled(const dif_hmac_t *hmac, - dif_hmac_irq_t irq, dif_toggle_t *state) { - if (hmac == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!hmac_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - hmac->base_addr, (ptrdiff_t)HMAC_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_set_enabled(const dif_hmac_t *hmac, - dif_hmac_irq_t irq, dif_toggle_t state) { - if (hmac == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!hmac_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - hmac->base_addr, (ptrdiff_t)HMAC_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(hmac->base_addr, (ptrdiff_t)HMAC_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_disable_all( - const dif_hmac_t *hmac, dif_hmac_irq_enable_snapshot_t *snapshot) { - if (hmac == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(hmac->base_addr, - (ptrdiff_t)HMAC_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(hmac->base_addr, (ptrdiff_t)HMAC_INTR_ENABLE_REG_OFFSET, - 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_restore_all( - const dif_hmac_t *hmac, const dif_hmac_irq_enable_snapshot_t *snapshot) { - if (hmac == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(hmac->base_addr, (ptrdiff_t)HMAC_INTR_ENABLE_REG_OFFSET, - *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_hmac_autogen.h b/sw/device/lib/dif/autogen/dif_hmac_autogen.h deleted file mode 100644 index 3104a5ac1c119..0000000000000 --- a/sw/device/lib/dif/autogen/dif_hmac_autogen.h +++ /dev/null @@ -1,251 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_HMAC_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_HMAC_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief HMAC Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to hmac. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_hmac { - /** - * The base address for the hmac hardware registers. - */ - mmio_region_t base_addr; -} dif_hmac_t; - -/** - * Creates a new handle for a(n) hmac peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the hmac peripheral. - * @param[out] hmac Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_init(mmio_region_t base_addr, dif_hmac_t *hmac); - -/** - * A hmac alert type. - */ -typedef enum dif_hmac_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifHmacAlertFatalFault = 0, -} dif_hmac_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param hmac A hmac handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_alert_force(const dif_hmac_t *hmac, - dif_hmac_alert_t alert); - -/** - * A hmac interrupt request type. - */ -typedef enum dif_hmac_irq { - /** - * HMAC/SHA-2 has completed. - */ - kDifHmacIrqHmacDone = 0, - /** - * The message FIFO is empty. This interrupt is raised only if the message - * FIFO is actually writable by software, i.e., if all of the following - * conditions are met: i) The HMAC block is not running in HMAC mode and - * performing the second round of computing the final hash of the outer key as - * well as the result of the first round using the inner key. ii) Software has - * not yet written the Process or Stop command to finish the hashing - * operation. For the interrupt to be raised, the message FIFO must also have - * been full previously. Otherwise, the hardware empties the FIFO faster than - * software can fill it and there is no point in interrupting the software to - * inform it about the message FIFO being empty. - */ - kDifHmacIrqFifoEmpty = 1, - /** - * HMAC error has occurred. ERR_CODE register shows which error occurred. - */ - kDifHmacIrqHmacErr = 2, -} dif_hmac_irq_t; - -/** - * 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()` - * and `dif_hmac_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_hmac_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param hmac A hmac handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_get_type(const dif_hmac_t *hmac, dif_hmac_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param hmac A hmac handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_get_state(const dif_hmac_t *hmac, - dif_hmac_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param hmac A hmac handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param hmac A hmac handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_acknowledge_all(const dif_hmac_t *hmac); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param hmac A hmac handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_acknowledge(const dif_hmac_t *hmac, - dif_hmac_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param hmac A hmac handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_force(const dif_hmac_t *hmac, dif_hmac_irq_t irq, - const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_hmac_irq_disable_all()` and `dif_hmac_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_hmac_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param hmac A hmac handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_get_enabled(const dif_hmac_t *hmac, - dif_hmac_irq_t irq, dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param hmac A hmac handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_set_enabled(const dif_hmac_t *hmac, - dif_hmac_irq_t irq, dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param hmac A hmac handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_disable_all(const dif_hmac_t *hmac, - dif_hmac_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param hmac A hmac handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_hmac_irq_restore_all( - const dif_hmac_t *hmac, const dif_hmac_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_HMAC_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_hmac_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_hmac_autogen_unittest.cc deleted file mode 100644 index 458e0808e6fbe..0000000000000 --- a/sw/device/lib/dif/autogen/dif_hmac_autogen_unittest.cc +++ /dev/null @@ -1,383 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_hmac_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "hmac_regs.h" // Generated. - -namespace dif_hmac_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class HmacTest : public Test, public MmioTest { - protected: - dif_hmac_t hmac_ = {.base_addr = dev().region()}; -}; - -class InitTest : public HmacTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_hmac_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_hmac_init(dev().region(), &hmac_)); -} - -class AlertForceTest : public HmacTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_hmac_alert_force(nullptr, kDifHmacAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_hmac_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(HMAC_ALERT_TEST_REG_OFFSET, - {{HMAC_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_hmac_alert_force(&hmac_, kDifHmacAlertFatalFault)); -} - -class IrqGetTypeTest : public HmacTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_hmac_irq_get_type(nullptr, kDifHmacIrqHmacDone, &type)); - - EXPECT_DIF_BADARG( - dif_hmac_irq_get_type(&hmac_, kDifHmacIrqHmacDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_hmac_irq_get_type(nullptr, kDifHmacIrqHmacDone, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_hmac_irq_get_type( - &hmac_, static_cast(kDifHmacIrqHmacErr + 1), &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_hmac_irq_get_type(&hmac_, kDifHmacIrqHmacDone, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public HmacTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_hmac_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_hmac_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_hmac_irq_get_state(&hmac_, nullptr)); - - EXPECT_DIF_BADARG(dif_hmac_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_hmac_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(HMAC_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_hmac_irq_get_state(&hmac_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public HmacTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG( - dif_hmac_irq_is_pending(nullptr, kDifHmacIrqHmacDone, &is_pending)); - - EXPECT_DIF_BADARG( - dif_hmac_irq_is_pending(&hmac_, kDifHmacIrqHmacDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_hmac_irq_is_pending(nullptr, kDifHmacIrqHmacDone, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_hmac_irq_is_pending( - &hmac_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(HMAC_INTR_STATE_REG_OFFSET, - {{HMAC_INTR_STATE_HMAC_DONE_BIT, true}}); - EXPECT_DIF_OK( - dif_hmac_irq_is_pending(&hmac_, kDifHmacIrqHmacDone, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(HMAC_INTR_STATE_REG_OFFSET, - {{HMAC_INTR_STATE_HMAC_ERR_BIT, false}}); - EXPECT_DIF_OK( - dif_hmac_irq_is_pending(&hmac_, kDifHmacIrqHmacErr, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 3; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_hmac_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(HMAC_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_hmac_irq_acknowledge_all(&hmac_)); -} - -class IrqAcknowledgeTest : public HmacTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG(dif_hmac_irq_acknowledge(nullptr, kDifHmacIrqHmacDone)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_hmac_irq_acknowledge(nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(HMAC_INTR_STATE_REG_OFFSET, - {{HMAC_INTR_STATE_HMAC_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_hmac_irq_acknowledge(&hmac_, kDifHmacIrqHmacDone)); - - // Clear the last IRQ state. - EXPECT_WRITE32(HMAC_INTR_STATE_REG_OFFSET, - {{HMAC_INTR_STATE_HMAC_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_hmac_irq_acknowledge(&hmac_, kDifHmacIrqHmacErr)); -} - -class IrqForceTest : public HmacTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_hmac_irq_force(nullptr, kDifHmacIrqHmacDone, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_hmac_irq_force(nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(HMAC_INTR_TEST_REG_OFFSET, - {{HMAC_INTR_TEST_HMAC_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_hmac_irq_force(&hmac_, kDifHmacIrqHmacDone, true)); - - // Force last IRQ. - EXPECT_WRITE32(HMAC_INTR_TEST_REG_OFFSET, - {{HMAC_INTR_TEST_HMAC_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_hmac_irq_force(&hmac_, kDifHmacIrqHmacErr, true)); -} - -class IrqGetEnabledTest : public HmacTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG( - dif_hmac_irq_get_enabled(nullptr, kDifHmacIrqHmacDone, &irq_state)); - - EXPECT_DIF_BADARG( - dif_hmac_irq_get_enabled(&hmac_, kDifHmacIrqHmacDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_hmac_irq_get_enabled(nullptr, kDifHmacIrqHmacDone, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_hmac_irq_get_enabled( - &hmac_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(HMAC_INTR_ENABLE_REG_OFFSET, - {{HMAC_INTR_ENABLE_HMAC_DONE_BIT, true}}); - EXPECT_DIF_OK( - dif_hmac_irq_get_enabled(&hmac_, kDifHmacIrqHmacDone, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(HMAC_INTR_ENABLE_REG_OFFSET, - {{HMAC_INTR_ENABLE_HMAC_ERR_BIT, false}}); - EXPECT_DIF_OK( - dif_hmac_irq_get_enabled(&hmac_, kDifHmacIrqHmacErr, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public HmacTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG( - dif_hmac_irq_set_enabled(nullptr, kDifHmacIrqHmacDone, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_hmac_irq_set_enabled( - &hmac_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(HMAC_INTR_ENABLE_REG_OFFSET, - {{HMAC_INTR_ENABLE_HMAC_DONE_BIT, 0x1, true}}); - EXPECT_DIF_OK( - dif_hmac_irq_set_enabled(&hmac_, kDifHmacIrqHmacDone, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(HMAC_INTR_ENABLE_REG_OFFSET, - {{HMAC_INTR_ENABLE_HMAC_ERR_BIT, 0x1, false}}); - EXPECT_DIF_OK( - dif_hmac_irq_set_enabled(&hmac_, kDifHmacIrqHmacErr, irq_state)); -} - -class IrqDisableAllTest : public HmacTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_hmac_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_hmac_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_hmac_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(HMAC_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_hmac_irq_disable_all(&hmac_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_hmac_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(HMAC_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(HMAC_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_hmac_irq_disable_all(&hmac_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_hmac_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(HMAC_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(HMAC_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_hmac_irq_disable_all(&hmac_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public HmacTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_hmac_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_hmac_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_hmac_irq_restore_all(&hmac_, nullptr)); - - EXPECT_DIF_BADARG(dif_hmac_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_hmac_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(HMAC_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_hmac_irq_restore_all(&hmac_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_hmac_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(HMAC_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_hmac_irq_restore_all(&hmac_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_hmac_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_i2c_autogen.c b/sw/device/lib/dif/autogen/dif_i2c_autogen.c deleted file mode 100644 index 67f0257062855..0000000000000 --- a/sw/device/lib/dif/autogen/dif_i2c_autogen.c +++ /dev/null @@ -1,297 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_i2c_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "i2c_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_init(mmio_region_t base_addr, dif_i2c_t *i2c) { - if (i2c == NULL) { - return kDifBadArg; - } - - i2c->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_i2c_alert_force(const dif_i2c_t *i2c, dif_i2c_alert_t alert) { - if (i2c == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifI2cAlertFatalFault: - alert_idx = I2C_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(i2c->base_addr, (ptrdiff_t)I2C_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool i2c_get_irq_bit_index(dif_i2c_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifI2cIrqFmtThreshold: - *index_out = I2C_INTR_COMMON_FMT_THRESHOLD_BIT; - break; - case kDifI2cIrqRxThreshold: - *index_out = I2C_INTR_COMMON_RX_THRESHOLD_BIT; - break; - case kDifI2cIrqAcqThreshold: - *index_out = I2C_INTR_COMMON_ACQ_THRESHOLD_BIT; - break; - case kDifI2cIrqRxOverflow: - *index_out = I2C_INTR_COMMON_RX_OVERFLOW_BIT; - break; - case kDifI2cIrqControllerHalt: - *index_out = I2C_INTR_COMMON_CONTROLLER_HALT_BIT; - break; - case kDifI2cIrqSclInterference: - *index_out = I2C_INTR_COMMON_SCL_INTERFERENCE_BIT; - break; - case kDifI2cIrqSdaInterference: - *index_out = I2C_INTR_COMMON_SDA_INTERFERENCE_BIT; - break; - case kDifI2cIrqStretchTimeout: - *index_out = I2C_INTR_COMMON_STRETCH_TIMEOUT_BIT; - break; - case kDifI2cIrqSdaUnstable: - *index_out = I2C_INTR_COMMON_SDA_UNSTABLE_BIT; - break; - case kDifI2cIrqCmdComplete: - *index_out = I2C_INTR_COMMON_CMD_COMPLETE_BIT; - break; - case kDifI2cIrqTxStretch: - *index_out = I2C_INTR_COMMON_TX_STRETCH_BIT; - break; - case kDifI2cIrqTxThreshold: - *index_out = I2C_INTR_COMMON_TX_THRESHOLD_BIT; - break; - case kDifI2cIrqAcqStretch: - *index_out = I2C_INTR_COMMON_ACQ_STRETCH_BIT; - break; - case kDifI2cIrqUnexpStop: - *index_out = I2C_INTR_COMMON_UNEXP_STOP_BIT; - break; - case kDifI2cIrqHostTimeout: - *index_out = I2C_INTR_COMMON_HOST_TIMEOUT_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeStatus, kDifIrqTypeStatus, kDifIrqTypeStatus, kDifIrqTypeEvent, - kDifIrqTypeStatus, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, - kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeStatus, kDifIrqTypeStatus, - kDifIrqTypeStatus, kDifIrqTypeEvent, kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_get_type(const dif_i2c_t *i2c, dif_i2c_irq_t irq, - dif_irq_type_t *type) { - if (i2c == NULL || type == NULL || irq < 0 || irq > kDifI2cIrqHostTimeout) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_get_state(const dif_i2c_t *i2c, - dif_i2c_irq_state_snapshot_t *snapshot) { - if (i2c == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = - mmio_region_read32(i2c->base_addr, (ptrdiff_t)I2C_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, (ptrdiff_t)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) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!i2c_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = - mmio_region_read32(i2c->base_addr, (ptrdiff_t)I2C_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_acknowledge_all(const dif_i2c_t *i2c) { - if (i2c == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(i2c->base_addr, (ptrdiff_t)I2C_INTR_STATE_REG_OFFSET, - UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_acknowledge(const dif_i2c_t *i2c, dif_i2c_irq_t irq) { - if (i2c == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!i2c_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(i2c->base_addr, (ptrdiff_t)I2C_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_force(const dif_i2c_t *i2c, dif_i2c_irq_t irq, - const bool val) { - if (i2c == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!i2c_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(i2c->base_addr, (ptrdiff_t)I2C_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_get_enabled(const dif_i2c_t *i2c, dif_i2c_irq_t irq, - dif_toggle_t *state) { - if (i2c == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!i2c_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = - mmio_region_read32(i2c->base_addr, (ptrdiff_t)I2C_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_set_enabled(const dif_i2c_t *i2c, dif_i2c_irq_t irq, - dif_toggle_t state) { - if (i2c == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!i2c_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = - mmio_region_read32(i2c->base_addr, (ptrdiff_t)I2C_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(i2c->base_addr, (ptrdiff_t)I2C_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_disable_all(const dif_i2c_t *i2c, - dif_i2c_irq_enable_snapshot_t *snapshot) { - if (i2c == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(i2c->base_addr, - (ptrdiff_t)I2C_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(i2c->base_addr, (ptrdiff_t)I2C_INTR_ENABLE_REG_OFFSET, - 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_restore_all( - const dif_i2c_t *i2c, const dif_i2c_irq_enable_snapshot_t *snapshot) { - if (i2c == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(i2c->base_addr, (ptrdiff_t)I2C_INTR_ENABLE_REG_OFFSET, - *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_i2c_autogen.h b/sw/device/lib/dif/autogen/dif_i2c_autogen.h deleted file mode 100644 index acf86e07d31eb..0000000000000 --- a/sw/device/lib/dif/autogen/dif_i2c_autogen.h +++ /dev/null @@ -1,306 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_I2C_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_I2C_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief I2C Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to i2c. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_i2c { - /** - * The base address for the i2c hardware registers. - */ - mmio_region_t base_addr; -} dif_i2c_t; - -/** - * Creates a new handle for a(n) i2c peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the i2c peripheral. - * @param[out] i2c Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_init(mmio_region_t base_addr, dif_i2c_t *i2c); - -/** - * A i2c alert type. - */ -typedef enum dif_i2c_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifI2cAlertFatalFault = 0, -} dif_i2c_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param i2c A i2c handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_alert_force(const dif_i2c_t *i2c, dif_i2c_alert_t alert); - -/** - * A i2c interrupt request type. - */ -typedef enum dif_i2c_irq { - /** - * Host mode interrupt: asserted whilst the FMT FIFO level is below the low - * threshold. This is a level status interrupt. - */ - kDifI2cIrqFmtThreshold = 0, - /** - * Host mode interrupt: asserted whilst the RX FIFO level is above the high - * threshold. This is a level status interrupt. - */ - kDifI2cIrqRxThreshold = 1, - /** - * Target mode interrupt: asserted whilst the ACQ FIFO level is above the high - * threshold. This is a level status interrupt. - */ - kDifI2cIrqAcqThreshold = 2, - /** - * Host mode interrupt: raised if the RX FIFO has overflowed. - */ - kDifI2cIrqRxOverflow = 3, - /** - * Host mode interrupt: raised if the controller FSM is halted, such as on an - * unexpected NACK or lost arbitration. Check !!CONTROLLER_EVENTS for the - * reason. The interrupt will be released when the bits in !!CONTROLLER_EVENTS - * are cleared. - */ - kDifI2cIrqControllerHalt = 4, - /** - * Host mode interrupt: raised if the SCL line drops early (not supported - * without clock synchronization). - */ - kDifI2cIrqSclInterference = 5, - /** - * Host mode interrupt: raised if the SDA line goes low when host is trying to - * assert high - */ - kDifI2cIrqSdaInterference = 6, - /** - * Host mode interrupt: raised if target stretches the clock beyond the - * allowed timeout period - */ - kDifI2cIrqStretchTimeout = 7, - /** - * Host mode interrupt: raised if the target does not assert a constant value - * of SDA during transmission. - */ - kDifI2cIrqSdaUnstable = 8, - /** - * Host and target mode interrupt. In host mode, raised if the host issues a - * repeated START or terminates the transaction by issuing STOP. In target - * mode, raised if the external host issues a STOP or repeated START. - */ - kDifI2cIrqCmdComplete = 9, - /** - * Target mode interrupt: raised if the target is stretching clocks for a read - * command. This is a level status interrupt. - */ - kDifI2cIrqTxStretch = 10, - /** - * Target mode interrupt: asserted whilst the TX FIFO level is below the low - * threshold. This is a level status interrupt. - */ - kDifI2cIrqTxThreshold = 11, - /** - * Target mode interrupt: raised if the target is stretching clocks due to - * full ACQ FIFO or zero count in !!TARGET_ACK_CTRL.NBYTES (if enabled). This - * is a level status interrupt. - */ - kDifI2cIrqAcqStretch = 12, - /** - * Target mode interrupt: raised if STOP is received without a preceding NACK - * during an external host read. - */ - kDifI2cIrqUnexpStop = 13, - /** - * Target mode interrupt: raised if the host stops sending the clock during an - * ongoing transaction. - */ - kDifI2cIrqHostTimeout = 14, -} dif_i2c_irq_t; - -/** - * 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()` - * and `dif_i2c_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_i2c_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param i2c A i2c handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_get_type(const dif_i2c_t *i2c, dif_i2c_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param i2c A i2c handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_get_state(const dif_i2c_t *i2c, - dif_i2c_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param i2c A i2c handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param i2c A i2c handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_acknowledge_all(const dif_i2c_t *i2c); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param i2c A i2c handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_acknowledge(const dif_i2c_t *i2c, dif_i2c_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param i2c A i2c handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_force(const dif_i2c_t *i2c, dif_i2c_irq_t irq, - const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_i2c_irq_disable_all()` and `dif_i2c_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_i2c_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param i2c A i2c handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_get_enabled(const dif_i2c_t *i2c, dif_i2c_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param i2c A i2c handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_set_enabled(const dif_i2c_t *i2c, dif_i2c_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param i2c A i2c handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_disable_all(const dif_i2c_t *i2c, - dif_i2c_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param i2c A i2c handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_i2c_irq_restore_all( - const dif_i2c_t *i2c, const dif_i2c_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_I2C_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_i2c_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_i2c_autogen_unittest.cc deleted file mode 100644 index 45083f40e5e6b..0000000000000 --- a/sw/device/lib/dif/autogen/dif_i2c_autogen_unittest.cc +++ /dev/null @@ -1,384 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_i2c_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "i2c_regs.h" // Generated. - -namespace dif_i2c_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class I2cTest : public Test, public MmioTest { - protected: - dif_i2c_t i2c_ = {.base_addr = dev().region()}; -}; - -class InitTest : public I2cTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_i2c_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_i2c_init(dev().region(), &i2c_)); -} - -class AlertForceTest : public I2cTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_i2c_alert_force(nullptr, kDifI2cAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_i2c_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(I2C_ALERT_TEST_REG_OFFSET, - {{I2C_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_i2c_alert_force(&i2c_, kDifI2cAlertFatalFault)); -} - -class IrqGetTypeTest : public I2cTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG( - dif_i2c_irq_get_type(nullptr, kDifI2cIrqFmtThreshold, &type)); - - EXPECT_DIF_BADARG( - dif_i2c_irq_get_type(&i2c_, kDifI2cIrqFmtThreshold, nullptr)); - - EXPECT_DIF_BADARG( - dif_i2c_irq_get_type(nullptr, kDifI2cIrqFmtThreshold, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_i2c_irq_get_type( - &i2c_, static_cast(kDifI2cIrqHostTimeout + 1), &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_i2c_irq_get_type(&i2c_, kDifI2cIrqFmtThreshold, &type)); - EXPECT_EQ(type, kDifIrqTypeStatus); -} - -class IrqGetStateTest : public I2cTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_i2c_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_i2c_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_i2c_irq_get_state(&i2c_, nullptr)); - - EXPECT_DIF_BADARG(dif_i2c_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_i2c_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(I2C_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_i2c_irq_get_state(&i2c_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public I2cTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG( - dif_i2c_irq_is_pending(nullptr, kDifI2cIrqFmtThreshold, &is_pending)); - - EXPECT_DIF_BADARG( - dif_i2c_irq_is_pending(&i2c_, kDifI2cIrqFmtThreshold, nullptr)); - - EXPECT_DIF_BADARG( - dif_i2c_irq_is_pending(nullptr, kDifI2cIrqFmtThreshold, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_i2c_irq_is_pending( - &i2c_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(I2C_INTR_STATE_REG_OFFSET, - {{I2C_INTR_STATE_FMT_THRESHOLD_BIT, true}}); - EXPECT_DIF_OK( - dif_i2c_irq_is_pending(&i2c_, kDifI2cIrqFmtThreshold, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(I2C_INTR_STATE_REG_OFFSET, - {{I2C_INTR_STATE_HOST_TIMEOUT_BIT, false}}); - EXPECT_DIF_OK( - dif_i2c_irq_is_pending(&i2c_, kDifI2cIrqHostTimeout, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 15; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_i2c_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(I2C_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_i2c_irq_acknowledge_all(&i2c_)); -} - -class IrqAcknowledgeTest : public I2cTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG(dif_i2c_irq_acknowledge(nullptr, kDifI2cIrqFmtThreshold)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_i2c_irq_acknowledge(nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(I2C_INTR_STATE_REG_OFFSET, - {{I2C_INTR_STATE_FMT_THRESHOLD_BIT, true}}); - EXPECT_DIF_OK(dif_i2c_irq_acknowledge(&i2c_, kDifI2cIrqFmtThreshold)); - - // Clear the last IRQ state. - EXPECT_WRITE32(I2C_INTR_STATE_REG_OFFSET, - {{I2C_INTR_STATE_HOST_TIMEOUT_BIT, true}}); - EXPECT_DIF_OK(dif_i2c_irq_acknowledge(&i2c_, kDifI2cIrqHostTimeout)); -} - -class IrqForceTest : public I2cTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_i2c_irq_force(nullptr, kDifI2cIrqFmtThreshold, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_i2c_irq_force(nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(I2C_INTR_TEST_REG_OFFSET, - {{I2C_INTR_TEST_FMT_THRESHOLD_BIT, true}}); - EXPECT_DIF_OK(dif_i2c_irq_force(&i2c_, kDifI2cIrqFmtThreshold, true)); - - // Force last IRQ. - EXPECT_WRITE32(I2C_INTR_TEST_REG_OFFSET, - {{I2C_INTR_TEST_HOST_TIMEOUT_BIT, true}}); - EXPECT_DIF_OK(dif_i2c_irq_force(&i2c_, kDifI2cIrqHostTimeout, true)); -} - -class IrqGetEnabledTest : public I2cTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG( - dif_i2c_irq_get_enabled(nullptr, kDifI2cIrqFmtThreshold, &irq_state)); - - EXPECT_DIF_BADARG( - dif_i2c_irq_get_enabled(&i2c_, kDifI2cIrqFmtThreshold, nullptr)); - - EXPECT_DIF_BADARG( - dif_i2c_irq_get_enabled(nullptr, kDifI2cIrqFmtThreshold, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_i2c_irq_get_enabled( - &i2c_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(I2C_INTR_ENABLE_REG_OFFSET, - {{I2C_INTR_ENABLE_FMT_THRESHOLD_BIT, true}}); - EXPECT_DIF_OK( - dif_i2c_irq_get_enabled(&i2c_, kDifI2cIrqFmtThreshold, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(I2C_INTR_ENABLE_REG_OFFSET, - {{I2C_INTR_ENABLE_HOST_TIMEOUT_BIT, false}}); - EXPECT_DIF_OK( - dif_i2c_irq_get_enabled(&i2c_, kDifI2cIrqHostTimeout, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public I2cTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG( - dif_i2c_irq_set_enabled(nullptr, kDifI2cIrqFmtThreshold, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_i2c_irq_set_enabled( - &i2c_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(I2C_INTR_ENABLE_REG_OFFSET, - {{I2C_INTR_ENABLE_FMT_THRESHOLD_BIT, 0x1, true}}); - EXPECT_DIF_OK( - dif_i2c_irq_set_enabled(&i2c_, kDifI2cIrqFmtThreshold, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(I2C_INTR_ENABLE_REG_OFFSET, - {{I2C_INTR_ENABLE_HOST_TIMEOUT_BIT, 0x1, false}}); - EXPECT_DIF_OK( - dif_i2c_irq_set_enabled(&i2c_, kDifI2cIrqHostTimeout, irq_state)); -} - -class IrqDisableAllTest : public I2cTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_i2c_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_i2c_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_i2c_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(I2C_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_i2c_irq_disable_all(&i2c_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_i2c_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(I2C_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(I2C_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_i2c_irq_disable_all(&i2c_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_i2c_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(I2C_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(I2C_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_i2c_irq_disable_all(&i2c_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public I2cTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_i2c_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_i2c_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_i2c_irq_restore_all(&i2c_, nullptr)); - - EXPECT_DIF_BADARG(dif_i2c_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_i2c_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(I2C_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_i2c_irq_restore_all(&i2c_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_i2c_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(I2C_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_i2c_irq_restore_all(&i2c_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_i2c_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_keymgr_autogen.c b/sw/device/lib/dif/autogen/dif_keymgr_autogen.c deleted file mode 100644 index ea9eb73611fe2..0000000000000 --- a/sw/device/lib/dif/autogen/dif_keymgr_autogen.c +++ /dev/null @@ -1,262 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_keymgr_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "keymgr_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_init(mmio_region_t base_addr, dif_keymgr_t *keymgr) { - if (keymgr == NULL) { - return kDifBadArg; - } - - keymgr->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_keymgr_alert_force(const dif_keymgr_t *keymgr, - dif_keymgr_alert_t alert) { - if (keymgr == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifKeymgrAlertRecovOperationErr: - alert_idx = KEYMGR_ALERT_TEST_RECOV_OPERATION_ERR_BIT; - break; - case kDifKeymgrAlertFatalFaultErr: - alert_idx = KEYMGR_ALERT_TEST_FATAL_FAULT_ERR_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(keymgr->base_addr, - (ptrdiff_t)KEYMGR_ALERT_TEST_REG_OFFSET, alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool keymgr_get_irq_bit_index(dif_keymgr_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifKeymgrIrqOpDone: - *index_out = KEYMGR_INTR_COMMON_OP_DONE_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_get_type(const dif_keymgr_t *keymgr, - dif_keymgr_irq_t irq, - dif_irq_type_t *type) { - if (keymgr == NULL || type == NULL || irq < 0 || irq > kDifKeymgrIrqOpDone) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_get_state( - const dif_keymgr_t *keymgr, dif_keymgr_irq_state_snapshot_t *snapshot) { - if (keymgr == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(keymgr->base_addr, - (ptrdiff_t)KEYMGR_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, - (ptrdiff_t)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) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!keymgr_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - keymgr->base_addr, (ptrdiff_t)KEYMGR_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_acknowledge_all(const dif_keymgr_t *keymgr) { - if (keymgr == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(keymgr->base_addr, - (ptrdiff_t)KEYMGR_INTR_STATE_REG_OFFSET, UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_acknowledge(const dif_keymgr_t *keymgr, - dif_keymgr_irq_t irq) { - if (keymgr == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!keymgr_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(keymgr->base_addr, - (ptrdiff_t)KEYMGR_INTR_STATE_REG_OFFSET, intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_force(const dif_keymgr_t *keymgr, - dif_keymgr_irq_t irq, const bool val) { - if (keymgr == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!keymgr_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(keymgr->base_addr, (ptrdiff_t)KEYMGR_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_get_enabled(const dif_keymgr_t *keymgr, - dif_keymgr_irq_t irq, - dif_toggle_t *state) { - if (keymgr == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!keymgr_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - keymgr->base_addr, (ptrdiff_t)KEYMGR_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_set_enabled(const dif_keymgr_t *keymgr, - dif_keymgr_irq_t irq, - dif_toggle_t state) { - if (keymgr == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!keymgr_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - keymgr->base_addr, (ptrdiff_t)KEYMGR_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(keymgr->base_addr, - (ptrdiff_t)KEYMGR_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_disable_all( - const dif_keymgr_t *keymgr, dif_keymgr_irq_enable_snapshot_t *snapshot) { - if (keymgr == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(keymgr->base_addr, - (ptrdiff_t)KEYMGR_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(keymgr->base_addr, - (ptrdiff_t)KEYMGR_INTR_ENABLE_REG_OFFSET, 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_restore_all( - const dif_keymgr_t *keymgr, - const dif_keymgr_irq_enable_snapshot_t *snapshot) { - if (keymgr == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(keymgr->base_addr, - (ptrdiff_t)KEYMGR_INTR_ENABLE_REG_OFFSET, *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_keymgr_autogen.h b/sw/device/lib/dif/autogen/dif_keymgr_autogen.h deleted file mode 100644 index b77b4379551f0..0000000000000 --- a/sw/device/lib/dif/autogen/dif_keymgr_autogen.h +++ /dev/null @@ -1,242 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_KEYMGR_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_KEYMGR_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief KEYMGR Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to keymgr. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_keymgr { - /** - * The base address for the keymgr hardware registers. - */ - mmio_region_t base_addr; -} dif_keymgr_t; - -/** - * Creates a new handle for a(n) keymgr peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the keymgr peripheral. - * @param[out] keymgr Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_init(mmio_region_t base_addr, dif_keymgr_t *keymgr); - -/** - * A keymgr alert type. - */ -typedef enum dif_keymgr_alert { - /** - * Alert for key manager operation errors. These errors could have been - * caused by software - */ - kDifKeymgrAlertRecovOperationErr = 0, - /** - * Alert for key manager faults. These errors cannot be caused by software - */ - kDifKeymgrAlertFatalFaultErr = 1, -} dif_keymgr_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param keymgr A keymgr handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_alert_force(const dif_keymgr_t *keymgr, - dif_keymgr_alert_t alert); - -/** - * A keymgr interrupt request type. - */ -typedef enum dif_keymgr_irq { - /** - * Operation complete - */ - kDifKeymgrIrqOpDone = 0, -} dif_keymgr_irq_t; - -/** - * 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()` - * and `dif_keymgr_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_keymgr_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param keymgr A keymgr handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_get_type(const dif_keymgr_t *keymgr, - dif_keymgr_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param keymgr A keymgr handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_get_state( - const dif_keymgr_t *keymgr, dif_keymgr_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param keymgr A keymgr handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param keymgr A keymgr handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_acknowledge_all(const dif_keymgr_t *keymgr); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param keymgr A keymgr handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_acknowledge(const dif_keymgr_t *keymgr, - dif_keymgr_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param keymgr A keymgr handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_force(const dif_keymgr_t *keymgr, - dif_keymgr_irq_t irq, const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_keymgr_irq_disable_all()` and `dif_keymgr_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_keymgr_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param keymgr A keymgr handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_get_enabled(const dif_keymgr_t *keymgr, - dif_keymgr_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param keymgr A keymgr handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_set_enabled(const dif_keymgr_t *keymgr, - dif_keymgr_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param keymgr A keymgr handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_disable_all( - const dif_keymgr_t *keymgr, dif_keymgr_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param keymgr A keymgr handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_irq_restore_all( - const dif_keymgr_t *keymgr, - const dif_keymgr_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_KEYMGR_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_keymgr_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_keymgr_autogen_unittest.cc deleted file mode 100644 index 0503cfd1650bc..0000000000000 --- a/sw/device/lib/dif/autogen/dif_keymgr_autogen_unittest.cc +++ /dev/null @@ -1,358 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_keymgr_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "keymgr_regs.h" // Generated. - -namespace dif_keymgr_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class KeymgrTest : public Test, public MmioTest { - protected: - dif_keymgr_t keymgr_ = {.base_addr = dev().region()}; -}; - -class InitTest : public KeymgrTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_keymgr_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_keymgr_init(dev().region(), &keymgr_)); -} - -class AlertForceTest : public KeymgrTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_keymgr_alert_force(nullptr, kDifKeymgrAlertRecovOperationErr)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_keymgr_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(KEYMGR_ALERT_TEST_REG_OFFSET, - {{KEYMGR_ALERT_TEST_RECOV_OPERATION_ERR_BIT, true}}); - EXPECT_DIF_OK( - dif_keymgr_alert_force(&keymgr_, kDifKeymgrAlertRecovOperationErr)); - - // Force last alert. - EXPECT_WRITE32(KEYMGR_ALERT_TEST_REG_OFFSET, - {{KEYMGR_ALERT_TEST_FATAL_FAULT_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_keymgr_alert_force(&keymgr_, kDifKeymgrAlertFatalFaultErr)); -} - -class IrqGetTypeTest : public KeymgrTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG( - dif_keymgr_irq_get_type(nullptr, kDifKeymgrIrqOpDone, &type)); - - EXPECT_DIF_BADARG( - dif_keymgr_irq_get_type(&keymgr_, kDifKeymgrIrqOpDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_keymgr_irq_get_type(nullptr, kDifKeymgrIrqOpDone, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_keymgr_irq_get_type( - &keymgr_, static_cast(kDifKeymgrIrqOpDone + 1), &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_keymgr_irq_get_type(&keymgr_, kDifKeymgrIrqOpDone, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public KeymgrTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_keymgr_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_keymgr_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_keymgr_irq_get_state(&keymgr_, nullptr)); - - EXPECT_DIF_BADARG(dif_keymgr_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_keymgr_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(KEYMGR_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_keymgr_irq_get_state(&keymgr_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public KeymgrTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG( - dif_keymgr_irq_is_pending(nullptr, kDifKeymgrIrqOpDone, &is_pending)); - - EXPECT_DIF_BADARG( - dif_keymgr_irq_is_pending(&keymgr_, kDifKeymgrIrqOpDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_keymgr_irq_is_pending(nullptr, kDifKeymgrIrqOpDone, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_keymgr_irq_is_pending( - &keymgr_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(KEYMGR_INTR_STATE_REG_OFFSET, - {{KEYMGR_INTR_STATE_OP_DONE_BIT, true}}); - EXPECT_DIF_OK( - dif_keymgr_irq_is_pending(&keymgr_, kDifKeymgrIrqOpDone, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 1; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_keymgr_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(KEYMGR_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_keymgr_irq_acknowledge_all(&keymgr_)); -} - -class IrqAcknowledgeTest : public KeymgrTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG(dif_keymgr_irq_acknowledge(nullptr, kDifKeymgrIrqOpDone)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_keymgr_irq_acknowledge(nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(KEYMGR_INTR_STATE_REG_OFFSET, - {{KEYMGR_INTR_STATE_OP_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_keymgr_irq_acknowledge(&keymgr_, kDifKeymgrIrqOpDone)); -} - -class IrqForceTest : public KeymgrTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_keymgr_irq_force(nullptr, kDifKeymgrIrqOpDone, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_keymgr_irq_force(nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(KEYMGR_INTR_TEST_REG_OFFSET, - {{KEYMGR_INTR_TEST_OP_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_keymgr_irq_force(&keymgr_, kDifKeymgrIrqOpDone, true)); -} - -class IrqGetEnabledTest : public KeymgrTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG( - dif_keymgr_irq_get_enabled(nullptr, kDifKeymgrIrqOpDone, &irq_state)); - - EXPECT_DIF_BADARG( - dif_keymgr_irq_get_enabled(&keymgr_, kDifKeymgrIrqOpDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_keymgr_irq_get_enabled(nullptr, kDifKeymgrIrqOpDone, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_keymgr_irq_get_enabled( - &keymgr_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(KEYMGR_INTR_ENABLE_REG_OFFSET, - {{KEYMGR_INTR_ENABLE_OP_DONE_BIT, true}}); - EXPECT_DIF_OK( - dif_keymgr_irq_get_enabled(&keymgr_, kDifKeymgrIrqOpDone, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); -} - -class IrqSetEnabledTest : public KeymgrTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG( - dif_keymgr_irq_set_enabled(nullptr, kDifKeymgrIrqOpDone, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_keymgr_irq_set_enabled( - &keymgr_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(KEYMGR_INTR_ENABLE_REG_OFFSET, - {{KEYMGR_INTR_ENABLE_OP_DONE_BIT, 0x1, true}}); - EXPECT_DIF_OK( - dif_keymgr_irq_set_enabled(&keymgr_, kDifKeymgrIrqOpDone, irq_state)); -} - -class IrqDisableAllTest : public KeymgrTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_keymgr_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_keymgr_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_keymgr_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(KEYMGR_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_keymgr_irq_disable_all(&keymgr_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_keymgr_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(KEYMGR_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(KEYMGR_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_keymgr_irq_disable_all(&keymgr_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_keymgr_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(KEYMGR_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(KEYMGR_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_keymgr_irq_disable_all(&keymgr_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public KeymgrTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_keymgr_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_keymgr_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_keymgr_irq_restore_all(&keymgr_, nullptr)); - - EXPECT_DIF_BADARG(dif_keymgr_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_keymgr_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(KEYMGR_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_keymgr_irq_restore_all(&keymgr_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_keymgr_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(KEYMGR_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_keymgr_irq_restore_all(&keymgr_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_keymgr_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_keymgr_dpe_autogen.c b/sw/device/lib/dif/autogen/dif_keymgr_dpe_autogen.c deleted file mode 100644 index 0a1a9c69e50b5..0000000000000 --- a/sw/device/lib/dif/autogen/dif_keymgr_dpe_autogen.c +++ /dev/null @@ -1,273 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_keymgr_dpe_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "keymgr_dpe_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_init(mmio_region_t base_addr, - dif_keymgr_dpe_t *keymgr_dpe) { - if (keymgr_dpe == NULL) { - return kDifBadArg; - } - - keymgr_dpe->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_keymgr_dpe_alert_force(const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_alert_t alert) { - if (keymgr_dpe == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifKeymgrDpeAlertRecovOperationErr: - alert_idx = KEYMGR_DPE_ALERT_TEST_RECOV_OPERATION_ERR_BIT; - break; - case kDifKeymgrDpeAlertFatalFaultErr: - alert_idx = KEYMGR_DPE_ALERT_TEST_FATAL_FAULT_ERR_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(keymgr_dpe->base_addr, - (ptrdiff_t)KEYMGR_DPE_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool keymgr_dpe_get_irq_bit_index(dif_keymgr_dpe_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifKeymgrDpeIrqOpDone: - *index_out = KEYMGR_DPE_INTR_COMMON_OP_DONE_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_get_type(const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_t irq, - dif_irq_type_t *type) { - if (keymgr_dpe == NULL || type == NULL || irq < 0 || - irq > kDifKeymgrDpeIrqOpDone) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_get_state( - const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_state_snapshot_t *snapshot) { - if (keymgr_dpe == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(keymgr_dpe->base_addr, - (ptrdiff_t)KEYMGR_DPE_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_acknowledge_state( - const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_state_snapshot_t snapshot) { - if (keymgr_dpe == NULL) { - return kDifBadArg; - } - - mmio_region_write32(keymgr_dpe->base_addr, - (ptrdiff_t)KEYMGR_DPE_INTR_STATE_REG_OFFSET, snapshot); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_is_pending(const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_t irq, - bool *is_pending) { - if (keymgr_dpe == NULL || is_pending == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!keymgr_dpe_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - keymgr_dpe->base_addr, (ptrdiff_t)KEYMGR_DPE_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_acknowledge_all( - const dif_keymgr_dpe_t *keymgr_dpe) { - if (keymgr_dpe == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(keymgr_dpe->base_addr, - (ptrdiff_t)KEYMGR_DPE_INTR_STATE_REG_OFFSET, UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_acknowledge(const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_t irq) { - if (keymgr_dpe == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!keymgr_dpe_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(keymgr_dpe->base_addr, - (ptrdiff_t)KEYMGR_DPE_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_force(const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_t irq, - const bool val) { - if (keymgr_dpe == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!keymgr_dpe_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(keymgr_dpe->base_addr, - (ptrdiff_t)KEYMGR_DPE_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_get_enabled(const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_t irq, - dif_toggle_t *state) { - if (keymgr_dpe == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!keymgr_dpe_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - keymgr_dpe->base_addr, (ptrdiff_t)KEYMGR_DPE_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_set_enabled(const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_t irq, - dif_toggle_t state) { - if (keymgr_dpe == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!keymgr_dpe_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - keymgr_dpe->base_addr, (ptrdiff_t)KEYMGR_DPE_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(keymgr_dpe->base_addr, - (ptrdiff_t)KEYMGR_DPE_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_disable_all( - const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_enable_snapshot_t *snapshot) { - if (keymgr_dpe == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32( - keymgr_dpe->base_addr, (ptrdiff_t)KEYMGR_DPE_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(keymgr_dpe->base_addr, - (ptrdiff_t)KEYMGR_DPE_INTR_ENABLE_REG_OFFSET, 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_restore_all( - const dif_keymgr_dpe_t *keymgr_dpe, - const dif_keymgr_dpe_irq_enable_snapshot_t *snapshot) { - if (keymgr_dpe == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(keymgr_dpe->base_addr, - (ptrdiff_t)KEYMGR_DPE_INTR_ENABLE_REG_OFFSET, *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_keymgr_dpe_autogen.h b/sw/device/lib/dif/autogen/dif_keymgr_dpe_autogen.h deleted file mode 100644 index 2a2796449156b..0000000000000 --- a/sw/device/lib/dif/autogen/dif_keymgr_dpe_autogen.h +++ /dev/null @@ -1,249 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_KEYMGR_DPE_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_KEYMGR_DPE_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief KEYMGR_DPE Device Interface - * Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to keymgr_dpe. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_keymgr_dpe { - /** - * The base address for the keymgr_dpe hardware registers. - */ - mmio_region_t base_addr; -} dif_keymgr_dpe_t; - -/** - * Creates a new handle for a(n) keymgr_dpe peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the keymgr_dpe peripheral. - * @param[out] keymgr_dpe Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_init(mmio_region_t base_addr, - dif_keymgr_dpe_t *keymgr_dpe); - -/** - * A keymgr_dpe alert type. - */ -typedef enum dif_keymgr_dpe_alert { - /** - * Alert for key manager operation errors. These errors could have been - * caused by software - */ - kDifKeymgrDpeAlertRecovOperationErr = 0, - /** - * Alert for key manager faults. These errors cannot be caused by software - */ - kDifKeymgrDpeAlertFatalFaultErr = 1, -} dif_keymgr_dpe_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param keymgr_dpe A keymgr_dpe handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_alert_force(const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_alert_t alert); - -/** - * A keymgr_dpe interrupt request type. - */ -typedef enum dif_keymgr_dpe_irq { - /** - * Operation complete - */ - kDifKeymgrDpeIrqOpDone = 0, -} dif_keymgr_dpe_irq_t; - -/** - * A snapshot of the state of the interrupts for this IP. - * - * This is an opaque type, to be used with the `dif_keymgr_dpe_irq_get_state()` - * and `dif_keymgr_dpe_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_keymgr_dpe_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param keymgr_dpe A keymgr_dpe handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_get_type(const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param keymgr_dpe A keymgr_dpe handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_get_state( - const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param keymgr_dpe A keymgr_dpe handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_is_pending(const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_t irq, - bool *is_pending); - -/** - * Acknowledges all interrupts that were pending at the time of the state - * snapshot. - * - * @param keymgr_dpe A keymgr_dpe handle. - * @param snapshot Interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_acknowledge_state( - const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_state_snapshot_t snapshot); - -/** - * Acknowledges all interrupts, indicating to the hardware that all - * interrupts have been successfully serviced. - * - * @param keymgr_dpe A keymgr_dpe handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_acknowledge_all( - const dif_keymgr_dpe_t *keymgr_dpe); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param keymgr_dpe A keymgr_dpe handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_acknowledge(const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param keymgr_dpe A keymgr_dpe handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_force(const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_t irq, const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_keymgr_dpe_irq_disable_all()` and `dif_keymgr_dpe_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_keymgr_dpe_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param keymgr_dpe A keymgr_dpe handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_get_enabled(const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param keymgr_dpe A keymgr_dpe handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_set_enabled(const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param keymgr_dpe A keymgr_dpe handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_disable_all( - const dif_keymgr_dpe_t *keymgr_dpe, - dif_keymgr_dpe_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param keymgr_dpe A keymgr_dpe handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_keymgr_dpe_irq_restore_all( - const dif_keymgr_dpe_t *keymgr_dpe, - const dif_keymgr_dpe_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_KEYMGR_DPE_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_keymgr_dpe_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_keymgr_dpe_autogen_unittest.cc deleted file mode 100644 index 4ce79da70c077..0000000000000 --- a/sw/device/lib/dif/autogen/dif_keymgr_dpe_autogen_unittest.cc +++ /dev/null @@ -1,367 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_keymgr_dpe_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "keymgr_dpe_regs.h" // Generated. - -namespace dif_keymgr_dpe_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class KeymgrDpeTest : public Test, public MmioTest { - protected: - dif_keymgr_dpe_t keymgr_dpe_ = {.base_addr = dev().region()}; -}; - -class InitTest : public KeymgrDpeTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_keymgr_dpe_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_keymgr_dpe_init(dev().region(), &keymgr_dpe_)); -} - -class AlertForceTest : public KeymgrDpeTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_keymgr_dpe_alert_force(nullptr, kDifKeymgrDpeAlertRecovOperationErr)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG(dif_keymgr_dpe_alert_force( - nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(KEYMGR_DPE_ALERT_TEST_REG_OFFSET, - {{KEYMGR_DPE_ALERT_TEST_RECOV_OPERATION_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_keymgr_dpe_alert_force( - &keymgr_dpe_, kDifKeymgrDpeAlertRecovOperationErr)); - - // Force last alert. - EXPECT_WRITE32(KEYMGR_DPE_ALERT_TEST_REG_OFFSET, - {{KEYMGR_DPE_ALERT_TEST_FATAL_FAULT_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_keymgr_dpe_alert_force(&keymgr_dpe_, - kDifKeymgrDpeAlertFatalFaultErr)); -} - -class IrqGetTypeTest : public KeymgrDpeTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG( - dif_keymgr_dpe_irq_get_type(nullptr, kDifKeymgrDpeIrqOpDone, &type)); - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_get_type( - &keymgr_dpe_, kDifKeymgrDpeIrqOpDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_keymgr_dpe_irq_get_type(nullptr, kDifKeymgrDpeIrqOpDone, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_get_type( - &keymgr_dpe_, - static_cast(kDifKeymgrDpeIrqOpDone + 1), &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK( - dif_keymgr_dpe_irq_get_type(&keymgr_dpe_, kDifKeymgrDpeIrqOpDone, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public KeymgrDpeTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_keymgr_dpe_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_get_state(&keymgr_dpe_, nullptr)); - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_keymgr_dpe_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(KEYMGR_DPE_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_keymgr_dpe_irq_get_state(&keymgr_dpe_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, SuccessNoneRaised) { - dif_keymgr_dpe_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(KEYMGR_DPE_INTR_STATE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_keymgr_dpe_irq_get_state(&keymgr_dpe_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -class IrqIsPendingTest : public KeymgrDpeTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_is_pending( - nullptr, kDifKeymgrDpeIrqOpDone, &is_pending)); - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_is_pending( - &keymgr_dpe_, kDifKeymgrDpeIrqOpDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_keymgr_dpe_irq_is_pending(nullptr, kDifKeymgrDpeIrqOpDone, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_is_pending( - &keymgr_dpe_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(KEYMGR_DPE_INTR_STATE_REG_OFFSET, - {{KEYMGR_DPE_INTR_STATE_OP_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_keymgr_dpe_irq_is_pending( - &keymgr_dpe_, kDifKeymgrDpeIrqOpDone, &irq_state)); - EXPECT_TRUE(irq_state); -} - -class AcknowledgeStateTest : public KeymgrDpeTest {}; - -TEST_F(AcknowledgeStateTest, NullArgs) { - dif_keymgr_dpe_irq_state_snapshot_t irq_snapshot = 0; - EXPECT_DIF_BADARG( - dif_keymgr_dpe_irq_acknowledge_state(nullptr, irq_snapshot)); -} - -TEST_F(AcknowledgeStateTest, AckSnapshot) { - constexpr uint32_t num_irqs = 1; - constexpr uint32_t irq_mask = (uint64_t{1} << num_irqs) - 1; - dif_keymgr_dpe_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_DPE_INTR_STATE_REG_OFFSET, irq_snapshot); - EXPECT_DIF_OK( - dif_keymgr_dpe_irq_acknowledge_state(&keymgr_dpe_, irq_snapshot)); - } -} - -TEST_F(AcknowledgeStateTest, SuccessNoneRaised) { - dif_keymgr_dpe_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(KEYMGR_DPE_INTR_STATE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_keymgr_dpe_irq_get_state(&keymgr_dpe_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -class AcknowledgeAllTest : public KeymgrDpeTest {}; - -TEST_F(AcknowledgeAllTest, NullArgs) { - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(KEYMGR_DPE_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_keymgr_dpe_irq_acknowledge_all(&keymgr_dpe_)); -} - -class IrqAcknowledgeTest : public KeymgrDpeTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_keymgr_dpe_irq_acknowledge(nullptr, kDifKeymgrDpeIrqOpDone)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_acknowledge( - nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(KEYMGR_DPE_INTR_STATE_REG_OFFSET, - {{KEYMGR_DPE_INTR_STATE_OP_DONE_BIT, true}}); - EXPECT_DIF_OK( - dif_keymgr_dpe_irq_acknowledge(&keymgr_dpe_, kDifKeymgrDpeIrqOpDone)); -} - -class IrqForceTest : public KeymgrDpeTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_keymgr_dpe_irq_force(nullptr, kDifKeymgrDpeIrqOpDone, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_force( - nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(KEYMGR_DPE_INTR_TEST_REG_OFFSET, - {{KEYMGR_DPE_INTR_TEST_OP_DONE_BIT, true}}); - EXPECT_DIF_OK( - dif_keymgr_dpe_irq_force(&keymgr_dpe_, kDifKeymgrDpeIrqOpDone, true)); -} - -class IrqGetEnabledTest : public KeymgrDpeTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_get_enabled( - nullptr, kDifKeymgrDpeIrqOpDone, &irq_state)); - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_get_enabled( - &keymgr_dpe_, kDifKeymgrDpeIrqOpDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_keymgr_dpe_irq_get_enabled(nullptr, kDifKeymgrDpeIrqOpDone, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_get_enabled( - &keymgr_dpe_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(KEYMGR_DPE_INTR_ENABLE_REG_OFFSET, - {{KEYMGR_DPE_INTR_ENABLE_OP_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_keymgr_dpe_irq_get_enabled( - &keymgr_dpe_, kDifKeymgrDpeIrqOpDone, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); -} - -class IrqSetEnabledTest : public KeymgrDpeTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_set_enabled( - nullptr, kDifKeymgrDpeIrqOpDone, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_set_enabled( - &keymgr_dpe_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(KEYMGR_DPE_INTR_ENABLE_REG_OFFSET, - {{KEYMGR_DPE_INTR_ENABLE_OP_DONE_BIT, 0x1, true}}); - EXPECT_DIF_OK(dif_keymgr_dpe_irq_set_enabled( - &keymgr_dpe_, kDifKeymgrDpeIrqOpDone, irq_state)); -} - -class IrqDisableAllTest : public KeymgrDpeTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_keymgr_dpe_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(KEYMGR_DPE_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_keymgr_dpe_irq_disable_all(&keymgr_dpe_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_keymgr_dpe_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(KEYMGR_DPE_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(KEYMGR_DPE_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_keymgr_dpe_irq_disable_all(&keymgr_dpe_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_keymgr_dpe_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(KEYMGR_DPE_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(KEYMGR_DPE_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_keymgr_dpe_irq_disable_all(&keymgr_dpe_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public KeymgrDpeTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_keymgr_dpe_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_restore_all(&keymgr_dpe_, nullptr)); - - EXPECT_DIF_BADARG(dif_keymgr_dpe_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_keymgr_dpe_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(KEYMGR_DPE_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_keymgr_dpe_irq_restore_all(&keymgr_dpe_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_keymgr_dpe_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(KEYMGR_DPE_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_keymgr_dpe_irq_restore_all(&keymgr_dpe_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_keymgr_dpe_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_kmac_autogen.c b/sw/device/lib/dif/autogen/dif_kmac_autogen.c deleted file mode 100644 index 25cecc29d0df7..0000000000000 --- a/sw/device/lib/dif/autogen/dif_kmac_autogen.c +++ /dev/null @@ -1,265 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_kmac_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "kmac_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_init(mmio_region_t base_addr, dif_kmac_t *kmac) { - if (kmac == NULL) { - return kDifBadArg; - } - - kmac->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_kmac_alert_force(const dif_kmac_t *kmac, - dif_kmac_alert_t alert) { - if (kmac == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifKmacAlertRecovOperationErr: - alert_idx = KMAC_ALERT_TEST_RECOV_OPERATION_ERR_BIT; - break; - case kDifKmacAlertFatalFaultErr: - alert_idx = KMAC_ALERT_TEST_FATAL_FAULT_ERR_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(kmac->base_addr, (ptrdiff_t)KMAC_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool kmac_get_irq_bit_index(dif_kmac_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifKmacIrqKmacDone: - *index_out = KMAC_INTR_COMMON_KMAC_DONE_BIT; - break; - case kDifKmacIrqFifoEmpty: - *index_out = KMAC_INTR_COMMON_FIFO_EMPTY_BIT; - break; - case kDifKmacIrqKmacErr: - *index_out = KMAC_INTR_COMMON_KMAC_ERR_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, - kDifIrqTypeStatus, - kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_get_type(const dif_kmac_t *kmac, dif_kmac_irq_t irq, - dif_irq_type_t *type) { - if (kmac == NULL || type == NULL || irq < 0 || irq > kDifKmacIrqKmacErr) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_get_state(const dif_kmac_t *kmac, - dif_kmac_irq_state_snapshot_t *snapshot) { - if (kmac == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(kmac->base_addr, - (ptrdiff_t)KMAC_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, (ptrdiff_t)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) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!kmac_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - kmac->base_addr, (ptrdiff_t)KMAC_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_acknowledge_all(const dif_kmac_t *kmac) { - if (kmac == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(kmac->base_addr, (ptrdiff_t)KMAC_INTR_STATE_REG_OFFSET, - UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_acknowledge(const dif_kmac_t *kmac, - dif_kmac_irq_t irq) { - if (kmac == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!kmac_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(kmac->base_addr, (ptrdiff_t)KMAC_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_force(const dif_kmac_t *kmac, dif_kmac_irq_t irq, - const bool val) { - if (kmac == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!kmac_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(kmac->base_addr, (ptrdiff_t)KMAC_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_get_enabled(const dif_kmac_t *kmac, - dif_kmac_irq_t irq, dif_toggle_t *state) { - if (kmac == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!kmac_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - kmac->base_addr, (ptrdiff_t)KMAC_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_set_enabled(const dif_kmac_t *kmac, - dif_kmac_irq_t irq, dif_toggle_t state) { - if (kmac == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!kmac_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - kmac->base_addr, (ptrdiff_t)KMAC_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(kmac->base_addr, (ptrdiff_t)KMAC_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_disable_all( - const dif_kmac_t *kmac, dif_kmac_irq_enable_snapshot_t *snapshot) { - if (kmac == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(kmac->base_addr, - (ptrdiff_t)KMAC_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(kmac->base_addr, (ptrdiff_t)KMAC_INTR_ENABLE_REG_OFFSET, - 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_restore_all( - const dif_kmac_t *kmac, const dif_kmac_irq_enable_snapshot_t *snapshot) { - if (kmac == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(kmac->base_addr, (ptrdiff_t)KMAC_INTR_ENABLE_REG_OFFSET, - *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_kmac_autogen.h b/sw/device/lib/dif/autogen/dif_kmac_autogen.h deleted file mode 100644 index acb2a1cd20805..0000000000000 --- a/sw/device/lib/dif/autogen/dif_kmac_autogen.h +++ /dev/null @@ -1,259 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_KMAC_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_KMAC_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief KMAC Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to kmac. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_kmac { - /** - * The base address for the kmac hardware registers. - */ - mmio_region_t base_addr; -} dif_kmac_t; - -/** - * Creates a new handle for a(n) kmac peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the kmac peripheral. - * @param[out] kmac Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_init(mmio_region_t base_addr, dif_kmac_t *kmac); - -/** - * A kmac alert type. - */ -typedef enum dif_kmac_alert { - /** - * Alert for KMAC operation error. It occurs when the shadow registers have - * update errors. - */ - kDifKmacAlertRecovOperationErr = 0, - /** - * This fatal alert is triggered when a fatal error is detected inside the - * KMAC unit. Examples for such faults include: i) TL-UL bus integrity fault. - * ii) Storage errors in the shadow registers. iii) Errors in the message, - * round, or key counter. iv) Any internal FSM entering an invalid state. v) - * An error in the redundant lfsr. The KMAC unit cannot recover from such an - * error and needs to be reset. - */ - kDifKmacAlertFatalFaultErr = 1, -} dif_kmac_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param kmac A kmac handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_alert_force(const dif_kmac_t *kmac, - dif_kmac_alert_t alert); - -/** - * A kmac interrupt request type. - */ -typedef enum dif_kmac_irq { - /** - * KMAC/SHA3 absorbing has been completed - */ - kDifKmacIrqKmacDone = 0, - /** - * The message FIFO is empty. This interrupt is raised only if the message - * FIFO is actually writable by software, i.e., if all of the following - * conditions are met: i) The KMAC block is not exercised by a hardware - * application interface. ii) The SHA3 block is in the Absorb state. iii) - * Software has not yet written the Process command to finish the absorption - * process. For the interrupt to be raised, the message FIFO must also have - * been full previously. Otherwise, the hardware empties the FIFO faster than - * software can fill it and there is no point in interrupting the software to - * inform it about the message FIFO being empty. - */ - kDifKmacIrqFifoEmpty = 1, - /** - * KMAC/SHA3 error occurred. ERR_CODE register shows the details - */ - kDifKmacIrqKmacErr = 2, -} dif_kmac_irq_t; - -/** - * 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()` - * and `dif_kmac_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_kmac_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param kmac A kmac handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_get_type(const dif_kmac_t *kmac, dif_kmac_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param kmac A kmac handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_get_state(const dif_kmac_t *kmac, - dif_kmac_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param kmac A kmac handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param kmac A kmac handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_acknowledge_all(const dif_kmac_t *kmac); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param kmac A kmac handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_acknowledge(const dif_kmac_t *kmac, - dif_kmac_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param kmac A kmac handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_force(const dif_kmac_t *kmac, dif_kmac_irq_t irq, - const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_kmac_irq_disable_all()` and `dif_kmac_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_kmac_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param kmac A kmac handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_get_enabled(const dif_kmac_t *kmac, - dif_kmac_irq_t irq, dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param kmac A kmac handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_set_enabled(const dif_kmac_t *kmac, - dif_kmac_irq_t irq, dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param kmac A kmac handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_disable_all(const dif_kmac_t *kmac, - dif_kmac_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param kmac A kmac handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_kmac_irq_restore_all( - const dif_kmac_t *kmac, const dif_kmac_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_KMAC_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_kmac_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_kmac_autogen_unittest.cc deleted file mode 100644 index 19c50a17e813b..0000000000000 --- a/sw/device/lib/dif/autogen/dif_kmac_autogen_unittest.cc +++ /dev/null @@ -1,389 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_kmac_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "kmac_regs.h" // Generated. - -namespace dif_kmac_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class KmacTest : public Test, public MmioTest { - protected: - dif_kmac_t kmac_ = {.base_addr = dev().region()}; -}; - -class InitTest : public KmacTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_kmac_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_kmac_init(dev().region(), &kmac_)); -} - -class AlertForceTest : public KmacTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_kmac_alert_force(nullptr, kDifKmacAlertRecovOperationErr)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_kmac_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(KMAC_ALERT_TEST_REG_OFFSET, - {{KMAC_ALERT_TEST_RECOV_OPERATION_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_kmac_alert_force(&kmac_, kDifKmacAlertRecovOperationErr)); - - // Force last alert. - EXPECT_WRITE32(KMAC_ALERT_TEST_REG_OFFSET, - {{KMAC_ALERT_TEST_FATAL_FAULT_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_kmac_alert_force(&kmac_, kDifKmacAlertFatalFaultErr)); -} - -class IrqGetTypeTest : public KmacTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_kmac_irq_get_type(nullptr, kDifKmacIrqKmacDone, &type)); - - EXPECT_DIF_BADARG( - dif_kmac_irq_get_type(&kmac_, kDifKmacIrqKmacDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_kmac_irq_get_type(nullptr, kDifKmacIrqKmacDone, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_kmac_irq_get_type( - &kmac_, static_cast(kDifKmacIrqKmacErr + 1), &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_kmac_irq_get_type(&kmac_, kDifKmacIrqKmacDone, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public KmacTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_kmac_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_kmac_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_kmac_irq_get_state(&kmac_, nullptr)); - - EXPECT_DIF_BADARG(dif_kmac_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_kmac_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(KMAC_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_kmac_irq_get_state(&kmac_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public KmacTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG( - dif_kmac_irq_is_pending(nullptr, kDifKmacIrqKmacDone, &is_pending)); - - EXPECT_DIF_BADARG( - dif_kmac_irq_is_pending(&kmac_, kDifKmacIrqKmacDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_kmac_irq_is_pending(nullptr, kDifKmacIrqKmacDone, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_kmac_irq_is_pending( - &kmac_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(KMAC_INTR_STATE_REG_OFFSET, - {{KMAC_INTR_STATE_KMAC_DONE_BIT, true}}); - EXPECT_DIF_OK( - dif_kmac_irq_is_pending(&kmac_, kDifKmacIrqKmacDone, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(KMAC_INTR_STATE_REG_OFFSET, - {{KMAC_INTR_STATE_KMAC_ERR_BIT, false}}); - EXPECT_DIF_OK( - dif_kmac_irq_is_pending(&kmac_, kDifKmacIrqKmacErr, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 3; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_kmac_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(KMAC_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_kmac_irq_acknowledge_all(&kmac_)); -} - -class IrqAcknowledgeTest : public KmacTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG(dif_kmac_irq_acknowledge(nullptr, kDifKmacIrqKmacDone)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_kmac_irq_acknowledge(nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(KMAC_INTR_STATE_REG_OFFSET, - {{KMAC_INTR_STATE_KMAC_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_kmac_irq_acknowledge(&kmac_, kDifKmacIrqKmacDone)); - - // Clear the last IRQ state. - EXPECT_WRITE32(KMAC_INTR_STATE_REG_OFFSET, - {{KMAC_INTR_STATE_KMAC_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_kmac_irq_acknowledge(&kmac_, kDifKmacIrqKmacErr)); -} - -class IrqForceTest : public KmacTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_kmac_irq_force(nullptr, kDifKmacIrqKmacDone, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_kmac_irq_force(nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(KMAC_INTR_TEST_REG_OFFSET, - {{KMAC_INTR_TEST_KMAC_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_kmac_irq_force(&kmac_, kDifKmacIrqKmacDone, true)); - - // Force last IRQ. - EXPECT_WRITE32(KMAC_INTR_TEST_REG_OFFSET, - {{KMAC_INTR_TEST_KMAC_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_kmac_irq_force(&kmac_, kDifKmacIrqKmacErr, true)); -} - -class IrqGetEnabledTest : public KmacTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG( - dif_kmac_irq_get_enabled(nullptr, kDifKmacIrqKmacDone, &irq_state)); - - EXPECT_DIF_BADARG( - dif_kmac_irq_get_enabled(&kmac_, kDifKmacIrqKmacDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_kmac_irq_get_enabled(nullptr, kDifKmacIrqKmacDone, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_kmac_irq_get_enabled( - &kmac_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(KMAC_INTR_ENABLE_REG_OFFSET, - {{KMAC_INTR_ENABLE_KMAC_DONE_BIT, true}}); - EXPECT_DIF_OK( - dif_kmac_irq_get_enabled(&kmac_, kDifKmacIrqKmacDone, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(KMAC_INTR_ENABLE_REG_OFFSET, - {{KMAC_INTR_ENABLE_KMAC_ERR_BIT, false}}); - EXPECT_DIF_OK( - dif_kmac_irq_get_enabled(&kmac_, kDifKmacIrqKmacErr, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public KmacTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG( - dif_kmac_irq_set_enabled(nullptr, kDifKmacIrqKmacDone, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_kmac_irq_set_enabled( - &kmac_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(KMAC_INTR_ENABLE_REG_OFFSET, - {{KMAC_INTR_ENABLE_KMAC_DONE_BIT, 0x1, true}}); - EXPECT_DIF_OK( - dif_kmac_irq_set_enabled(&kmac_, kDifKmacIrqKmacDone, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(KMAC_INTR_ENABLE_REG_OFFSET, - {{KMAC_INTR_ENABLE_KMAC_ERR_BIT, 0x1, false}}); - EXPECT_DIF_OK( - dif_kmac_irq_set_enabled(&kmac_, kDifKmacIrqKmacErr, irq_state)); -} - -class IrqDisableAllTest : public KmacTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_kmac_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_kmac_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_kmac_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(KMAC_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_kmac_irq_disable_all(&kmac_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_kmac_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(KMAC_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(KMAC_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_kmac_irq_disable_all(&kmac_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_kmac_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(KMAC_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(KMAC_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_kmac_irq_disable_all(&kmac_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public KmacTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_kmac_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_kmac_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_kmac_irq_restore_all(&kmac_, nullptr)); - - EXPECT_DIF_BADARG(dif_kmac_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_kmac_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(KMAC_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_kmac_irq_restore_all(&kmac_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_kmac_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(KMAC_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_kmac_irq_restore_all(&kmac_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_kmac_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_lc_ctrl_autogen.c b/sw/device/lib/dif/autogen/dif_lc_ctrl_autogen.c deleted file mode 100644 index 9e7abaef0d3a4..0000000000000 --- a/sw/device/lib/dif/autogen/dif_lc_ctrl_autogen.c +++ /dev/null @@ -1,53 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_lc_ctrl_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "lc_ctrl_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_lc_ctrl_init(mmio_region_t base_addr, dif_lc_ctrl_t *lc_ctrl) { - if (lc_ctrl == NULL) { - return kDifBadArg; - } - - lc_ctrl->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_lc_ctrl_alert_force(const dif_lc_ctrl_t *lc_ctrl, - dif_lc_ctrl_alert_t alert) { - if (lc_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifLcCtrlAlertFatalProgError: - alert_idx = LC_CTRL_ALERT_TEST_FATAL_PROG_ERROR_BIT; - break; - case kDifLcCtrlAlertFatalStateError: - alert_idx = LC_CTRL_ALERT_TEST_FATAL_STATE_ERROR_BIT; - break; - case kDifLcCtrlAlertFatalBusIntegError: - alert_idx = LC_CTRL_ALERT_TEST_FATAL_BUS_INTEG_ERROR_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(lc_ctrl->base_addr, - (ptrdiff_t)LC_CTRL_ALERT_TEST_REG_OFFSET, alert_test_reg); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_lc_ctrl_autogen.h b/sw/device/lib/dif/autogen/dif_lc_ctrl_autogen.h deleted file mode 100644 index e072b097a40b0..0000000000000 --- a/sw/device/lib/dif/autogen/dif_lc_ctrl_autogen.h +++ /dev/null @@ -1,88 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_LC_CTRL_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_LC_CTRL_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief LC_CTRL Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to lc_ctrl. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_lc_ctrl { - /** - * The base address for the lc_ctrl hardware registers. - */ - mmio_region_t base_addr; -} dif_lc_ctrl_t; - -/** - * Creates a new handle for a(n) lc_ctrl peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the lc_ctrl peripheral. - * @param[out] lc_ctrl Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_lc_ctrl_init(mmio_region_t base_addr, dif_lc_ctrl_t *lc_ctrl); - -/** - * A lc_ctrl alert type. - */ -typedef enum dif_lc_ctrl_alert { - /** - * This alert triggers if an error occurred during an OTP programming - * operation. - */ - kDifLcCtrlAlertFatalProgError = 0, - /** - * This alert triggers if an error in the life cycle state or life cycle - * controller FSM is detected. - */ - kDifLcCtrlAlertFatalStateError = 1, - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifLcCtrlAlertFatalBusIntegError = 2, -} dif_lc_ctrl_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param lc_ctrl A lc_ctrl handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_lc_ctrl_alert_force(const dif_lc_ctrl_t *lc_ctrl, - dif_lc_ctrl_alert_t alert); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_LC_CTRL_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_lc_ctrl_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_lc_ctrl_autogen_unittest.cc deleted file mode 100644 index 2f4f60cdfe793..0000000000000 --- a/sw/device/lib/dif/autogen/dif_lc_ctrl_autogen_unittest.cc +++ /dev/null @@ -1,66 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_lc_ctrl_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "lc_ctrl_regs.h" // Generated. - -namespace dif_lc_ctrl_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class LcCtrlTest : public Test, public MmioTest { - protected: - dif_lc_ctrl_t lc_ctrl_ = {.base_addr = dev().region()}; -}; - -class InitTest : public LcCtrlTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_lc_ctrl_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_lc_ctrl_init(dev().region(), &lc_ctrl_)); -} - -class AlertForceTest : public LcCtrlTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_lc_ctrl_alert_force(nullptr, kDifLcCtrlAlertFatalProgError)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_lc_ctrl_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(LC_CTRL_ALERT_TEST_REG_OFFSET, - {{LC_CTRL_ALERT_TEST_FATAL_PROG_ERROR_BIT, true}}); - EXPECT_DIF_OK( - dif_lc_ctrl_alert_force(&lc_ctrl_, kDifLcCtrlAlertFatalProgError)); - - // Force last alert. - EXPECT_WRITE32(LC_CTRL_ALERT_TEST_REG_OFFSET, - {{LC_CTRL_ALERT_TEST_FATAL_BUS_INTEG_ERROR_BIT, true}}); - EXPECT_DIF_OK( - dif_lc_ctrl_alert_force(&lc_ctrl_, kDifLcCtrlAlertFatalBusIntegError)); -} - -} // namespace -} // namespace dif_lc_ctrl_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_mbx_autogen.c b/sw/device/lib/dif/autogen/dif_mbx_autogen.c deleted file mode 100644 index 2c2ed3bdea8e1..0000000000000 --- a/sw/device/lib/dif/autogen/dif_mbx_autogen.c +++ /dev/null @@ -1,263 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_mbx_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "mbx_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_init(mmio_region_t base_addr, dif_mbx_t *mbx) { - if (mbx == NULL) { - return kDifBadArg; - } - - mbx->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_mbx_alert_force(const dif_mbx_t *mbx, dif_mbx_alert_t alert) { - if (mbx == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifMbxAlertFatalFault: - alert_idx = MBX_ALERT_TEST_FATAL_FAULT_BIT; - break; - case kDifMbxAlertRecovFault: - alert_idx = MBX_ALERT_TEST_RECOV_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(mbx->base_addr, (ptrdiff_t)MBX_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool mbx_get_irq_bit_index(dif_mbx_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifMbxIrqMbxReady: - *index_out = MBX_INTR_COMMON_MBX_READY_BIT; - break; - case kDifMbxIrqMbxAbort: - *index_out = MBX_INTR_COMMON_MBX_ABORT_BIT; - break; - case kDifMbxIrqMbxError: - *index_out = MBX_INTR_COMMON_MBX_ERROR_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, - kDifIrqTypeEvent, - kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_get_type(const dif_mbx_t *mbx, dif_mbx_irq_t irq, - dif_irq_type_t *type) { - if (mbx == NULL || type == NULL || irq < 0 || irq > kDifMbxIrqMbxError) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_get_state(const dif_mbx_t *mbx, - dif_mbx_irq_state_snapshot_t *snapshot) { - if (mbx == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = - mmio_region_read32(mbx->base_addr, (ptrdiff_t)MBX_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_acknowledge_state( - const dif_mbx_t *mbx, dif_mbx_irq_state_snapshot_t snapshot) { - if (mbx == NULL) { - return kDifBadArg; - } - - mmio_region_write32(mbx->base_addr, (ptrdiff_t)MBX_INTR_STATE_REG_OFFSET, - snapshot); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_is_pending(const dif_mbx_t *mbx, dif_mbx_irq_t irq, - bool *is_pending) { - if (mbx == NULL || is_pending == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!mbx_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = - mmio_region_read32(mbx->base_addr, (ptrdiff_t)MBX_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_acknowledge_all(const dif_mbx_t *mbx) { - if (mbx == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(mbx->base_addr, (ptrdiff_t)MBX_INTR_STATE_REG_OFFSET, - UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_acknowledge(const dif_mbx_t *mbx, dif_mbx_irq_t irq) { - if (mbx == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!mbx_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(mbx->base_addr, (ptrdiff_t)MBX_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_force(const dif_mbx_t *mbx, dif_mbx_irq_t irq, - const bool val) { - if (mbx == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!mbx_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(mbx->base_addr, (ptrdiff_t)MBX_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_get_enabled(const dif_mbx_t *mbx, dif_mbx_irq_t irq, - dif_toggle_t *state) { - if (mbx == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!mbx_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = - mmio_region_read32(mbx->base_addr, (ptrdiff_t)MBX_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_set_enabled(const dif_mbx_t *mbx, dif_mbx_irq_t irq, - dif_toggle_t state) { - if (mbx == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!mbx_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = - mmio_region_read32(mbx->base_addr, (ptrdiff_t)MBX_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(mbx->base_addr, (ptrdiff_t)MBX_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_disable_all(const dif_mbx_t *mbx, - dif_mbx_irq_enable_snapshot_t *snapshot) { - if (mbx == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(mbx->base_addr, - (ptrdiff_t)MBX_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(mbx->base_addr, (ptrdiff_t)MBX_INTR_ENABLE_REG_OFFSET, - 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_restore_all( - const dif_mbx_t *mbx, const dif_mbx_irq_enable_snapshot_t *snapshot) { - if (mbx == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(mbx->base_addr, (ptrdiff_t)MBX_INTR_ENABLE_REG_OFFSET, - *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_mbx_autogen.h b/sw/device/lib/dif/autogen/dif_mbx_autogen.h deleted file mode 100644 index c19b67c38b349..0000000000000 --- a/sw/device/lib/dif/autogen/dif_mbx_autogen.h +++ /dev/null @@ -1,245 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_MBX_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_MBX_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief MBX Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to mbx. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_mbx { - /** - * The base address for the mbx hardware registers. - */ - mmio_region_t base_addr; -} dif_mbx_t; - -/** - * Creates a new handle for a(n) mbx peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the mbx peripheral. - * @param[out] mbx Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_init(mmio_region_t base_addr, dif_mbx_t *mbx); - -/** - * A mbx alert type. - */ -typedef enum dif_mbx_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifMbxAlertFatalFault = 0, - /** - * This recoverable alert is triggered when memory with invalid ECC (e.g., - * uninitialized memory) or at an invalid address is accessed. - */ - kDifMbxAlertRecovFault = 1, -} dif_mbx_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param mbx A mbx handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_alert_force(const dif_mbx_t *mbx, dif_mbx_alert_t alert); - -/** - * A mbx interrupt request type. - */ -typedef enum dif_mbx_irq { - /** - * A new object was received in the inbound mailbox. - */ - kDifMbxIrqMbxReady = 0, - /** - * An abort request was received from the requester. - */ - kDifMbxIrqMbxAbort = 1, - /** - * The mailbox instance generated an error. - */ - kDifMbxIrqMbxError = 2, -} dif_mbx_irq_t; - -/** - * A snapshot of the state of the interrupts for this IP. - * - * This is an opaque type, to be used with the `dif_mbx_irq_get_state()` - * and `dif_mbx_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_mbx_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param mbx A mbx handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_get_type(const dif_mbx_t *mbx, dif_mbx_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param mbx A mbx handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_get_state(const dif_mbx_t *mbx, - dif_mbx_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param mbx A mbx handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_is_pending(const dif_mbx_t *mbx, dif_mbx_irq_t irq, - bool *is_pending); - -/** - * Acknowledges all interrupts that were pending at the time of the state - * snapshot. - * - * @param mbx A mbx handle. - * @param snapshot Interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_acknowledge_state( - const dif_mbx_t *mbx, dif_mbx_irq_state_snapshot_t snapshot); - -/** - * Acknowledges all interrupts, indicating to the hardware that all - * interrupts have been successfully serviced. - * - * @param mbx A mbx handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_acknowledge_all(const dif_mbx_t *mbx); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param mbx A mbx handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_acknowledge(const dif_mbx_t *mbx, dif_mbx_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param mbx A mbx handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_force(const dif_mbx_t *mbx, dif_mbx_irq_t irq, - const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_mbx_irq_disable_all()` and `dif_mbx_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_mbx_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param mbx A mbx handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_get_enabled(const dif_mbx_t *mbx, dif_mbx_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param mbx A mbx handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_set_enabled(const dif_mbx_t *mbx, dif_mbx_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param mbx A mbx handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_disable_all(const dif_mbx_t *mbx, - dif_mbx_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param mbx A mbx handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_mbx_irq_restore_all( - const dif_mbx_t *mbx, const dif_mbx_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_MBX_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_mbx_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_mbx_autogen_unittest.cc deleted file mode 100644 index a3d3468d5c404..0000000000000 --- a/sw/device/lib/dif/autogen/dif_mbx_autogen_unittest.cc +++ /dev/null @@ -1,379 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_mbx_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "mbx_regs.h" // Generated. - -namespace dif_mbx_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class MbxTest : public Test, public MmioTest { - protected: - dif_mbx_t mbx_ = {.base_addr = dev().region()}; -}; - -class InitTest : public MbxTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_mbx_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_mbx_init(dev().region(), &mbx_)); -} - -class AlertForceTest : public MbxTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_mbx_alert_force(nullptr, kDifMbxAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_mbx_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(MBX_ALERT_TEST_REG_OFFSET, - {{MBX_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_mbx_alert_force(&mbx_, kDifMbxAlertFatalFault)); - - // Force last alert. - EXPECT_WRITE32(MBX_ALERT_TEST_REG_OFFSET, - {{MBX_ALERT_TEST_RECOV_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_mbx_alert_force(&mbx_, kDifMbxAlertRecovFault)); -} - -class IrqGetTypeTest : public MbxTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_mbx_irq_get_type(nullptr, kDifMbxIrqMbxReady, &type)); - - EXPECT_DIF_BADARG(dif_mbx_irq_get_type(&mbx_, kDifMbxIrqMbxReady, nullptr)); - - EXPECT_DIF_BADARG(dif_mbx_irq_get_type(nullptr, kDifMbxIrqMbxReady, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_mbx_irq_get_type( - &mbx_, static_cast(kDifMbxIrqMbxError + 1), &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_mbx_irq_get_type(&mbx_, kDifMbxIrqMbxReady, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public MbxTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_mbx_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_mbx_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_mbx_irq_get_state(&mbx_, nullptr)); - - EXPECT_DIF_BADARG(dif_mbx_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_mbx_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(MBX_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_mbx_irq_get_state(&mbx_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, SuccessNoneRaised) { - dif_mbx_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(MBX_INTR_STATE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_mbx_irq_get_state(&mbx_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -class IrqIsPendingTest : public MbxTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG( - dif_mbx_irq_is_pending(nullptr, kDifMbxIrqMbxReady, &is_pending)); - - EXPECT_DIF_BADARG(dif_mbx_irq_is_pending(&mbx_, kDifMbxIrqMbxReady, nullptr)); - - EXPECT_DIF_BADARG( - dif_mbx_irq_is_pending(nullptr, kDifMbxIrqMbxReady, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_mbx_irq_is_pending( - &mbx_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(MBX_INTR_STATE_REG_OFFSET, - {{MBX_INTR_STATE_MBX_READY_BIT, true}}); - EXPECT_DIF_OK(dif_mbx_irq_is_pending(&mbx_, kDifMbxIrqMbxReady, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(MBX_INTR_STATE_REG_OFFSET, - {{MBX_INTR_STATE_MBX_ERROR_BIT, false}}); - EXPECT_DIF_OK(dif_mbx_irq_is_pending(&mbx_, kDifMbxIrqMbxError, &irq_state)); - EXPECT_FALSE(irq_state); -} - -class AcknowledgeStateTest : public MbxTest {}; - -TEST_F(AcknowledgeStateTest, NullArgs) { - dif_mbx_irq_state_snapshot_t irq_snapshot = 0; - EXPECT_DIF_BADARG(dif_mbx_irq_acknowledge_state(nullptr, irq_snapshot)); -} - -TEST_F(AcknowledgeStateTest, AckSnapshot) { - constexpr uint32_t num_irqs = 3; - constexpr uint32_t irq_mask = (uint64_t{1} << num_irqs) - 1; - dif_mbx_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(MBX_INTR_STATE_REG_OFFSET, irq_snapshot); - EXPECT_DIF_OK(dif_mbx_irq_acknowledge_state(&mbx_, irq_snapshot)); - } -} - -TEST_F(AcknowledgeStateTest, SuccessNoneRaised) { - dif_mbx_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(MBX_INTR_STATE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_mbx_irq_get_state(&mbx_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -class AcknowledgeAllTest : public MbxTest {}; - -TEST_F(AcknowledgeAllTest, NullArgs) { - EXPECT_DIF_BADARG(dif_mbx_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(MBX_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_mbx_irq_acknowledge_all(&mbx_)); -} - -class IrqAcknowledgeTest : public MbxTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG(dif_mbx_irq_acknowledge(nullptr, kDifMbxIrqMbxReady)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_mbx_irq_acknowledge(nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(MBX_INTR_STATE_REG_OFFSET, - {{MBX_INTR_STATE_MBX_READY_BIT, true}}); - EXPECT_DIF_OK(dif_mbx_irq_acknowledge(&mbx_, kDifMbxIrqMbxReady)); - - // Clear the last IRQ state. - EXPECT_WRITE32(MBX_INTR_STATE_REG_OFFSET, - {{MBX_INTR_STATE_MBX_ERROR_BIT, true}}); - EXPECT_DIF_OK(dif_mbx_irq_acknowledge(&mbx_, kDifMbxIrqMbxError)); -} - -class IrqForceTest : public MbxTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_mbx_irq_force(nullptr, kDifMbxIrqMbxReady, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_mbx_irq_force(nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(MBX_INTR_TEST_REG_OFFSET, - {{MBX_INTR_TEST_MBX_READY_BIT, true}}); - EXPECT_DIF_OK(dif_mbx_irq_force(&mbx_, kDifMbxIrqMbxReady, true)); - - // Force last IRQ. - EXPECT_WRITE32(MBX_INTR_TEST_REG_OFFSET, - {{MBX_INTR_TEST_MBX_ERROR_BIT, true}}); - EXPECT_DIF_OK(dif_mbx_irq_force(&mbx_, kDifMbxIrqMbxError, true)); -} - -class IrqGetEnabledTest : public MbxTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG( - dif_mbx_irq_get_enabled(nullptr, kDifMbxIrqMbxReady, &irq_state)); - - EXPECT_DIF_BADARG( - dif_mbx_irq_get_enabled(&mbx_, kDifMbxIrqMbxReady, nullptr)); - - EXPECT_DIF_BADARG( - dif_mbx_irq_get_enabled(nullptr, kDifMbxIrqMbxReady, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_mbx_irq_get_enabled( - &mbx_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(MBX_INTR_ENABLE_REG_OFFSET, - {{MBX_INTR_ENABLE_MBX_READY_BIT, true}}); - EXPECT_DIF_OK(dif_mbx_irq_get_enabled(&mbx_, kDifMbxIrqMbxReady, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(MBX_INTR_ENABLE_REG_OFFSET, - {{MBX_INTR_ENABLE_MBX_ERROR_BIT, false}}); - EXPECT_DIF_OK(dif_mbx_irq_get_enabled(&mbx_, kDifMbxIrqMbxError, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public MbxTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG( - dif_mbx_irq_set_enabled(nullptr, kDifMbxIrqMbxReady, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_mbx_irq_set_enabled( - &mbx_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(MBX_INTR_ENABLE_REG_OFFSET, - {{MBX_INTR_ENABLE_MBX_READY_BIT, 0x1, true}}); - EXPECT_DIF_OK(dif_mbx_irq_set_enabled(&mbx_, kDifMbxIrqMbxReady, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(MBX_INTR_ENABLE_REG_OFFSET, - {{MBX_INTR_ENABLE_MBX_ERROR_BIT, 0x1, false}}); - EXPECT_DIF_OK(dif_mbx_irq_set_enabled(&mbx_, kDifMbxIrqMbxError, irq_state)); -} - -class IrqDisableAllTest : public MbxTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_mbx_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_mbx_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_mbx_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(MBX_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_mbx_irq_disable_all(&mbx_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_mbx_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(MBX_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(MBX_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_mbx_irq_disable_all(&mbx_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_mbx_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(MBX_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(MBX_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_mbx_irq_disable_all(&mbx_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public MbxTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_mbx_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_mbx_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_mbx_irq_restore_all(&mbx_, nullptr)); - - EXPECT_DIF_BADARG(dif_mbx_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_mbx_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(MBX_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_mbx_irq_restore_all(&mbx_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_mbx_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(MBX_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_mbx_irq_restore_all(&mbx_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_mbx_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_otbn_autogen.c b/sw/device/lib/dif/autogen/dif_otbn_autogen.c deleted file mode 100644 index 0247c71ab612e..0000000000000 --- a/sw/device/lib/dif/autogen/dif_otbn_autogen.c +++ /dev/null @@ -1,257 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_otbn_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "otbn_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_init(mmio_region_t base_addr, dif_otbn_t *otbn) { - if (otbn == NULL) { - return kDifBadArg; - } - - otbn->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_otbn_alert_force(const dif_otbn_t *otbn, - dif_otbn_alert_t alert) { - if (otbn == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifOtbnAlertFatal: - alert_idx = OTBN_ALERT_TEST_FATAL_BIT; - break; - case kDifOtbnAlertRecov: - alert_idx = OTBN_ALERT_TEST_RECOV_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(otbn->base_addr, (ptrdiff_t)OTBN_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool otbn_get_irq_bit_index(dif_otbn_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifOtbnIrqDone: - *index_out = OTBN_INTR_COMMON_DONE_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_get_type(const dif_otbn_t *otbn, dif_otbn_irq_t irq, - dif_irq_type_t *type) { - if (otbn == NULL || type == NULL || irq < 0 || irq > kDifOtbnIrqDone) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_get_state(const dif_otbn_t *otbn, - dif_otbn_irq_state_snapshot_t *snapshot) { - if (otbn == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(otbn->base_addr, - (ptrdiff_t)OTBN_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, (ptrdiff_t)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) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!otbn_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - otbn->base_addr, (ptrdiff_t)OTBN_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_acknowledge_all(const dif_otbn_t *otbn) { - if (otbn == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(otbn->base_addr, (ptrdiff_t)OTBN_INTR_STATE_REG_OFFSET, - UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_acknowledge(const dif_otbn_t *otbn, - dif_otbn_irq_t irq) { - if (otbn == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!otbn_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(otbn->base_addr, (ptrdiff_t)OTBN_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_force(const dif_otbn_t *otbn, dif_otbn_irq_t irq, - const bool val) { - if (otbn == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!otbn_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(otbn->base_addr, (ptrdiff_t)OTBN_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_get_enabled(const dif_otbn_t *otbn, - dif_otbn_irq_t irq, dif_toggle_t *state) { - if (otbn == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!otbn_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - otbn->base_addr, (ptrdiff_t)OTBN_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_set_enabled(const dif_otbn_t *otbn, - dif_otbn_irq_t irq, dif_toggle_t state) { - if (otbn == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!otbn_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - otbn->base_addr, (ptrdiff_t)OTBN_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(otbn->base_addr, (ptrdiff_t)OTBN_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_disable_all( - const dif_otbn_t *otbn, dif_otbn_irq_enable_snapshot_t *snapshot) { - if (otbn == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(otbn->base_addr, - (ptrdiff_t)OTBN_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(otbn->base_addr, (ptrdiff_t)OTBN_INTR_ENABLE_REG_OFFSET, - 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_restore_all( - const dif_otbn_t *otbn, const dif_otbn_irq_enable_snapshot_t *snapshot) { - if (otbn == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(otbn->base_addr, (ptrdiff_t)OTBN_INTR_ENABLE_REG_OFFSET, - *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_otbn_autogen.h b/sw/device/lib/dif/autogen/dif_otbn_autogen.h deleted file mode 100644 index 7af33579ea65d..0000000000000 --- a/sw/device/lib/dif/autogen/dif_otbn_autogen.h +++ /dev/null @@ -1,238 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_OTBN_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_OTBN_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief OTBN Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to otbn. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_otbn { - /** - * The base address for the otbn hardware registers. - */ - mmio_region_t base_addr; -} dif_otbn_t; - -/** - * Creates a new handle for a(n) otbn peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the otbn peripheral. - * @param[out] otbn Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_init(mmio_region_t base_addr, dif_otbn_t *otbn); - -/** - * A otbn alert type. - */ -typedef enum dif_otbn_alert { - /** - * A fatal error. Fatal alerts are non-recoverable and will be asserted until - * a hard reset. - */ - kDifOtbnAlertFatal = 0, - /** - * A recoverable error. Just sent once (as the processor stops). - */ - kDifOtbnAlertRecov = 1, -} dif_otbn_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param otbn A otbn handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_alert_force(const dif_otbn_t *otbn, - dif_otbn_alert_t alert); - -/** - * A otbn interrupt request type. - */ -typedef enum dif_otbn_irq { - /** - * OTBN has completed the operation. - */ - kDifOtbnIrqDone = 0, -} dif_otbn_irq_t; - -/** - * 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()` - * and `dif_otbn_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_otbn_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param otbn A otbn handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_get_type(const dif_otbn_t *otbn, dif_otbn_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param otbn A otbn handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_get_state(const dif_otbn_t *otbn, - dif_otbn_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param otbn A otbn handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param otbn A otbn handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_acknowledge_all(const dif_otbn_t *otbn); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param otbn A otbn handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_acknowledge(const dif_otbn_t *otbn, - dif_otbn_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param otbn A otbn handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_force(const dif_otbn_t *otbn, dif_otbn_irq_t irq, - const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_otbn_irq_disable_all()` and `dif_otbn_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_otbn_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param otbn A otbn handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_get_enabled(const dif_otbn_t *otbn, - dif_otbn_irq_t irq, dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param otbn A otbn handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_set_enabled(const dif_otbn_t *otbn, - dif_otbn_irq_t irq, dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param otbn A otbn handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_disable_all(const dif_otbn_t *otbn, - dif_otbn_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param otbn A otbn handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otbn_irq_restore_all( - const dif_otbn_t *otbn, const dif_otbn_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_OTBN_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_otbn_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_otbn_autogen_unittest.cc deleted file mode 100644 index ee1b9c39f4018..0000000000000 --- a/sw/device/lib/dif/autogen/dif_otbn_autogen_unittest.cc +++ /dev/null @@ -1,345 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_otbn_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "otbn_regs.h" // Generated. - -namespace dif_otbn_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class OtbnTest : public Test, public MmioTest { - protected: - dif_otbn_t otbn_ = {.base_addr = dev().region()}; -}; - -class InitTest : public OtbnTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_otbn_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_otbn_init(dev().region(), &otbn_)); -} - -class AlertForceTest : public OtbnTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_otbn_alert_force(nullptr, kDifOtbnAlertFatal)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_otbn_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(OTBN_ALERT_TEST_REG_OFFSET, - {{OTBN_ALERT_TEST_FATAL_BIT, true}}); - EXPECT_DIF_OK(dif_otbn_alert_force(&otbn_, kDifOtbnAlertFatal)); - - // Force last alert. - EXPECT_WRITE32(OTBN_ALERT_TEST_REG_OFFSET, - {{OTBN_ALERT_TEST_RECOV_BIT, true}}); - EXPECT_DIF_OK(dif_otbn_alert_force(&otbn_, kDifOtbnAlertRecov)); -} - -class IrqGetTypeTest : public OtbnTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_otbn_irq_get_type(nullptr, kDifOtbnIrqDone, &type)); - - EXPECT_DIF_BADARG(dif_otbn_irq_get_type(&otbn_, kDifOtbnIrqDone, nullptr)); - - EXPECT_DIF_BADARG(dif_otbn_irq_get_type(nullptr, kDifOtbnIrqDone, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_otbn_irq_get_type( - &otbn_, static_cast(kDifOtbnIrqDone + 1), &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_otbn_irq_get_type(&otbn_, kDifOtbnIrqDone, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public OtbnTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_otbn_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_otbn_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_otbn_irq_get_state(&otbn_, nullptr)); - - EXPECT_DIF_BADARG(dif_otbn_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_otbn_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(OTBN_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_otbn_irq_get_state(&otbn_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public OtbnTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG( - dif_otbn_irq_is_pending(nullptr, kDifOtbnIrqDone, &is_pending)); - - EXPECT_DIF_BADARG(dif_otbn_irq_is_pending(&otbn_, kDifOtbnIrqDone, nullptr)); - - EXPECT_DIF_BADARG(dif_otbn_irq_is_pending(nullptr, kDifOtbnIrqDone, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_otbn_irq_is_pending( - &otbn_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(OTBN_INTR_STATE_REG_OFFSET, {{OTBN_INTR_STATE_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_otbn_irq_is_pending(&otbn_, kDifOtbnIrqDone, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 1; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_otbn_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(OTBN_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_otbn_irq_acknowledge_all(&otbn_)); -} - -class IrqAcknowledgeTest : public OtbnTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG(dif_otbn_irq_acknowledge(nullptr, kDifOtbnIrqDone)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_otbn_irq_acknowledge(nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(OTBN_INTR_STATE_REG_OFFSET, - {{OTBN_INTR_STATE_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_otbn_irq_acknowledge(&otbn_, kDifOtbnIrqDone)); -} - -class IrqForceTest : public OtbnTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_otbn_irq_force(nullptr, kDifOtbnIrqDone, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_otbn_irq_force(nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(OTBN_INTR_TEST_REG_OFFSET, {{OTBN_INTR_TEST_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_otbn_irq_force(&otbn_, kDifOtbnIrqDone, true)); -} - -class IrqGetEnabledTest : public OtbnTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG( - dif_otbn_irq_get_enabled(nullptr, kDifOtbnIrqDone, &irq_state)); - - EXPECT_DIF_BADARG(dif_otbn_irq_get_enabled(&otbn_, kDifOtbnIrqDone, nullptr)); - - EXPECT_DIF_BADARG( - dif_otbn_irq_get_enabled(nullptr, kDifOtbnIrqDone, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_otbn_irq_get_enabled( - &otbn_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(OTBN_INTR_ENABLE_REG_OFFSET, - {{OTBN_INTR_ENABLE_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_otbn_irq_get_enabled(&otbn_, kDifOtbnIrqDone, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); -} - -class IrqSetEnabledTest : public OtbnTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG( - dif_otbn_irq_set_enabled(nullptr, kDifOtbnIrqDone, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_otbn_irq_set_enabled( - &otbn_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(OTBN_INTR_ENABLE_REG_OFFSET, - {{OTBN_INTR_ENABLE_DONE_BIT, 0x1, true}}); - EXPECT_DIF_OK(dif_otbn_irq_set_enabled(&otbn_, kDifOtbnIrqDone, irq_state)); -} - -class IrqDisableAllTest : public OtbnTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_otbn_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_otbn_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_otbn_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(OTBN_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_otbn_irq_disable_all(&otbn_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_otbn_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(OTBN_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(OTBN_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_otbn_irq_disable_all(&otbn_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_otbn_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(OTBN_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(OTBN_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_otbn_irq_disable_all(&otbn_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public OtbnTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_otbn_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_otbn_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_otbn_irq_restore_all(&otbn_, nullptr)); - - EXPECT_DIF_BADARG(dif_otbn_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_otbn_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(OTBN_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_otbn_irq_restore_all(&otbn_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_otbn_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(OTBN_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_otbn_irq_restore_all(&otbn_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_otbn_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen.c b/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen.c deleted file mode 100644 index 8fbed16221c9d..0000000000000 --- a/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen.c +++ /dev/null @@ -1,283 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_otp_ctrl_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "otp_ctrl_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_init(mmio_region_t base_addr, - dif_otp_ctrl_t *otp_ctrl) { - if (otp_ctrl == NULL) { - return kDifBadArg; - } - - otp_ctrl->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_otp_ctrl_alert_force(const dif_otp_ctrl_t *otp_ctrl, - dif_otp_ctrl_alert_t alert) { - if (otp_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifOtpCtrlAlertFatalMacroError: - alert_idx = OTP_CTRL_ALERT_TEST_FATAL_MACRO_ERROR_BIT; - break; - case kDifOtpCtrlAlertFatalCheckError: - alert_idx = OTP_CTRL_ALERT_TEST_FATAL_CHECK_ERROR_BIT; - break; - case kDifOtpCtrlAlertFatalBusIntegError: - alert_idx = OTP_CTRL_ALERT_TEST_FATAL_BUS_INTEG_ERROR_BIT; - break; - case kDifOtpCtrlAlertFatalPrimOtpAlert: - alert_idx = OTP_CTRL_ALERT_TEST_FATAL_PRIM_OTP_ALERT_BIT; - break; - case kDifOtpCtrlAlertRecovPrimOtpAlert: - alert_idx = OTP_CTRL_ALERT_TEST_RECOV_PRIM_OTP_ALERT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(otp_ctrl->base_addr, - (ptrdiff_t)OTP_CTRL_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool otp_ctrl_get_irq_bit_index(dif_otp_ctrl_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifOtpCtrlIrqOtpOperationDone: - *index_out = OTP_CTRL_INTR_COMMON_OTP_OPERATION_DONE_BIT; - break; - case kDifOtpCtrlIrqOtpError: - *index_out = OTP_CTRL_INTR_COMMON_OTP_ERROR_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, - kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_get_type(const dif_otp_ctrl_t *otp_ctrl, - dif_otp_ctrl_irq_t irq, - dif_irq_type_t *type) { - if (otp_ctrl == NULL || type == NULL || irq < 0 || - irq > kDifOtpCtrlIrqOtpError) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_get_state( - const dif_otp_ctrl_t *otp_ctrl, - dif_otp_ctrl_irq_state_snapshot_t *snapshot) { - if (otp_ctrl == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(otp_ctrl->base_addr, - (ptrdiff_t)OTP_CTRL_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, - (ptrdiff_t)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) { - if (otp_ctrl == NULL || is_pending == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!otp_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - otp_ctrl->base_addr, (ptrdiff_t)OTP_CTRL_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_acknowledge_all(const dif_otp_ctrl_t *otp_ctrl) { - if (otp_ctrl == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(otp_ctrl->base_addr, - (ptrdiff_t)OTP_CTRL_INTR_STATE_REG_OFFSET, UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_acknowledge(const dif_otp_ctrl_t *otp_ctrl, - dif_otp_ctrl_irq_t irq) { - if (otp_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!otp_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(otp_ctrl->base_addr, - (ptrdiff_t)OTP_CTRL_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_force(const dif_otp_ctrl_t *otp_ctrl, - dif_otp_ctrl_irq_t irq, const bool val) { - if (otp_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!otp_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(otp_ctrl->base_addr, - (ptrdiff_t)OTP_CTRL_INTR_TEST_REG_OFFSET, intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_get_enabled(const dif_otp_ctrl_t *otp_ctrl, - dif_otp_ctrl_irq_t irq, - dif_toggle_t *state) { - if (otp_ctrl == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!otp_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - otp_ctrl->base_addr, (ptrdiff_t)OTP_CTRL_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_set_enabled(const dif_otp_ctrl_t *otp_ctrl, - dif_otp_ctrl_irq_t irq, - dif_toggle_t state) { - if (otp_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!otp_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - otp_ctrl->base_addr, (ptrdiff_t)OTP_CTRL_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(otp_ctrl->base_addr, - (ptrdiff_t)OTP_CTRL_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_disable_all( - const dif_otp_ctrl_t *otp_ctrl, - dif_otp_ctrl_irq_enable_snapshot_t *snapshot) { - if (otp_ctrl == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(otp_ctrl->base_addr, - (ptrdiff_t)OTP_CTRL_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(otp_ctrl->base_addr, - (ptrdiff_t)OTP_CTRL_INTR_ENABLE_REG_OFFSET, 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_restore_all( - const dif_otp_ctrl_t *otp_ctrl, - const dif_otp_ctrl_irq_enable_snapshot_t *snapshot) { - if (otp_ctrl == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(otp_ctrl->base_addr, - (ptrdiff_t)OTP_CTRL_INTR_ENABLE_REG_OFFSET, *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen.h b/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen.h deleted file mode 100644 index a93c61ab81a4e..0000000000000 --- a/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen.h +++ /dev/null @@ -1,267 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_OTP_CTRL_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_OTP_CTRL_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief OTP_CTRL Device Interface - * Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to otp_ctrl. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_otp_ctrl { - /** - * The base address for the otp_ctrl hardware registers. - */ - mmio_region_t base_addr; -} dif_otp_ctrl_t; - -/** - * Creates a new handle for a(n) otp_ctrl peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the otp_ctrl peripheral. - * @param[out] otp_ctrl Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_init(mmio_region_t base_addr, - dif_otp_ctrl_t *otp_ctrl); - -/** - * A otp_ctrl alert type. - */ -typedef enum dif_otp_ctrl_alert { - /** - * This alert triggers if hardware detects an uncorrectable error during an - * OTP transaction, for example an uncorrectable ECC error in the OTP array. - */ - kDifOtpCtrlAlertFatalMacroError = 0, - /** - * This alert triggers if any of the background checks fails. This includes - * the digest checks and concurrent ECC checks in the buffer registers. - */ - kDifOtpCtrlAlertFatalCheckError = 1, - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifOtpCtrlAlertFatalBusIntegError = 2, - /** - * Fatal alert triggered inside the OTP primitive, including fatal TL-UL bus - * integrity faults of the test interface. - */ - kDifOtpCtrlAlertFatalPrimOtpAlert = 3, - /** - * Recoverable alert triggered inside the OTP primitive. - */ - kDifOtpCtrlAlertRecovPrimOtpAlert = 4, -} dif_otp_ctrl_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param otp_ctrl A otp_ctrl handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_alert_force(const dif_otp_ctrl_t *otp_ctrl, - dif_otp_ctrl_alert_t alert); - -/** - * A otp_ctrl interrupt request type. - */ -typedef enum dif_otp_ctrl_irq { - /** - * A direct access command or digest calculation operation has completed. - */ - kDifOtpCtrlIrqOtpOperationDone = 0, - /** - * An error has occurred in the OTP controller. Check the !!ERR_CODE register - * to get more information. - */ - kDifOtpCtrlIrqOtpError = 1, -} dif_otp_ctrl_irq_t; - -/** - * 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()` - * and `dif_otp_ctrl_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_otp_ctrl_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param otp_ctrl A otp_ctrl handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_get_type(const dif_otp_ctrl_t *otp_ctrl, - dif_otp_ctrl_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param otp_ctrl A otp_ctrl handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_get_state( - const dif_otp_ctrl_t *otp_ctrl, - dif_otp_ctrl_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param otp_ctrl A otp_ctrl handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param otp_ctrl A otp_ctrl handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_acknowledge_all(const dif_otp_ctrl_t *otp_ctrl); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param otp_ctrl A otp_ctrl handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_acknowledge(const dif_otp_ctrl_t *otp_ctrl, - dif_otp_ctrl_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param otp_ctrl A otp_ctrl handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_force(const dif_otp_ctrl_t *otp_ctrl, - dif_otp_ctrl_irq_t irq, const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_otp_ctrl_irq_disable_all()` and `dif_otp_ctrl_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_otp_ctrl_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param otp_ctrl A otp_ctrl handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_get_enabled(const dif_otp_ctrl_t *otp_ctrl, - dif_otp_ctrl_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param otp_ctrl A otp_ctrl handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_set_enabled(const dif_otp_ctrl_t *otp_ctrl, - dif_otp_ctrl_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param otp_ctrl A otp_ctrl handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_disable_all( - const dif_otp_ctrl_t *otp_ctrl, - dif_otp_ctrl_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param otp_ctrl A otp_ctrl handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_otp_ctrl_irq_restore_all( - const dif_otp_ctrl_t *otp_ctrl, - const dif_otp_ctrl_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_OTP_CTRL_AUTOGEN_H_ 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 deleted file mode 100644 index 5f5e4e2f5e356..0000000000000 --- a/sw/device/lib/dif/autogen/dif_otp_ctrl_autogen_unittest.cc +++ /dev/null @@ -1,400 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_otp_ctrl_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "otp_ctrl_regs.h" // Generated. - -namespace dif_otp_ctrl_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class OtpCtrlTest : public Test, public MmioTest { - protected: - dif_otp_ctrl_t otp_ctrl_ = {.base_addr = dev().region()}; -}; - -class InitTest : public OtpCtrlTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_otp_ctrl_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_otp_ctrl_init(dev().region(), &otp_ctrl_)); -} - -class AlertForceTest : public OtpCtrlTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_otp_ctrl_alert_force(nullptr, kDifOtpCtrlAlertFatalMacroError)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_otp_ctrl_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(OTP_CTRL_ALERT_TEST_REG_OFFSET, - {{OTP_CTRL_ALERT_TEST_FATAL_MACRO_ERROR_BIT, true}}); - EXPECT_DIF_OK( - dif_otp_ctrl_alert_force(&otp_ctrl_, kDifOtpCtrlAlertFatalMacroError)); - - // Force last alert. - EXPECT_WRITE32(OTP_CTRL_ALERT_TEST_REG_OFFSET, - {{OTP_CTRL_ALERT_TEST_RECOV_PRIM_OTP_ALERT_BIT, true}}); - EXPECT_DIF_OK( - dif_otp_ctrl_alert_force(&otp_ctrl_, kDifOtpCtrlAlertRecovPrimOtpAlert)); -} - -class IrqGetTypeTest : public OtpCtrlTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_get_type( - nullptr, kDifOtpCtrlIrqOtpOperationDone, &type)); - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_get_type( - &otp_ctrl_, kDifOtpCtrlIrqOtpOperationDone, nullptr)); - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_get_type( - nullptr, kDifOtpCtrlIrqOtpOperationDone, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_get_type( - &otp_ctrl_, static_cast(kDifOtpCtrlIrqOtpError + 1), - &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_otp_ctrl_irq_get_type( - &otp_ctrl_, kDifOtpCtrlIrqOtpOperationDone, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public OtpCtrlTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_otp_ctrl_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_get_state(&otp_ctrl_, nullptr)); - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_otp_ctrl_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(OTP_CTRL_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_otp_ctrl_irq_get_state(&otp_ctrl_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public OtpCtrlTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_is_pending( - nullptr, kDifOtpCtrlIrqOtpOperationDone, &is_pending)); - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_is_pending( - &otp_ctrl_, kDifOtpCtrlIrqOtpOperationDone, nullptr)); - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_is_pending( - nullptr, kDifOtpCtrlIrqOtpOperationDone, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_is_pending( - &otp_ctrl_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(OTP_CTRL_INTR_STATE_REG_OFFSET, - {{OTP_CTRL_INTR_STATE_OTP_OPERATION_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_otp_ctrl_irq_is_pending( - &otp_ctrl_, kDifOtpCtrlIrqOtpOperationDone, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(OTP_CTRL_INTR_STATE_REG_OFFSET, - {{OTP_CTRL_INTR_STATE_OTP_ERROR_BIT, false}}); - EXPECT_DIF_OK(dif_otp_ctrl_irq_is_pending(&otp_ctrl_, kDifOtpCtrlIrqOtpError, - &irq_state)); - 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) { - constexpr uint32_t num_irqs = 2; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(OTP_CTRL_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_otp_ctrl_irq_acknowledge_all(&otp_ctrl_)); -} - -class IrqAcknowledgeTest : public OtpCtrlTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_otp_ctrl_irq_acknowledge(nullptr, kDifOtpCtrlIrqOtpOperationDone)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_acknowledge( - nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(OTP_CTRL_INTR_STATE_REG_OFFSET, - {{OTP_CTRL_INTR_STATE_OTP_OPERATION_DONE_BIT, true}}); - EXPECT_DIF_OK( - dif_otp_ctrl_irq_acknowledge(&otp_ctrl_, kDifOtpCtrlIrqOtpOperationDone)); - - // Clear the last IRQ state. - EXPECT_WRITE32(OTP_CTRL_INTR_STATE_REG_OFFSET, - {{OTP_CTRL_INTR_STATE_OTP_ERROR_BIT, true}}); - EXPECT_DIF_OK( - dif_otp_ctrl_irq_acknowledge(&otp_ctrl_, kDifOtpCtrlIrqOtpError)); -} - -class IrqForceTest : public OtpCtrlTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_otp_ctrl_irq_force(nullptr, kDifOtpCtrlIrqOtpOperationDone, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_force( - nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(OTP_CTRL_INTR_TEST_REG_OFFSET, - {{OTP_CTRL_INTR_TEST_OTP_OPERATION_DONE_BIT, true}}); - EXPECT_DIF_OK( - dif_otp_ctrl_irq_force(&otp_ctrl_, kDifOtpCtrlIrqOtpOperationDone, true)); - - // Force last IRQ. - EXPECT_WRITE32(OTP_CTRL_INTR_TEST_REG_OFFSET, - {{OTP_CTRL_INTR_TEST_OTP_ERROR_BIT, true}}); - EXPECT_DIF_OK( - dif_otp_ctrl_irq_force(&otp_ctrl_, kDifOtpCtrlIrqOtpError, true)); -} - -class IrqGetEnabledTest : public OtpCtrlTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_get_enabled( - nullptr, kDifOtpCtrlIrqOtpOperationDone, &irq_state)); - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_get_enabled( - &otp_ctrl_, kDifOtpCtrlIrqOtpOperationDone, nullptr)); - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_get_enabled( - nullptr, kDifOtpCtrlIrqOtpOperationDone, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_get_enabled( - &otp_ctrl_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(OTP_CTRL_INTR_ENABLE_REG_OFFSET, - {{OTP_CTRL_INTR_ENABLE_OTP_OPERATION_DONE_BIT, true}}); - EXPECT_DIF_OK(dif_otp_ctrl_irq_get_enabled( - &otp_ctrl_, kDifOtpCtrlIrqOtpOperationDone, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(OTP_CTRL_INTR_ENABLE_REG_OFFSET, - {{OTP_CTRL_INTR_ENABLE_OTP_ERROR_BIT, false}}); - EXPECT_DIF_OK(dif_otp_ctrl_irq_get_enabled(&otp_ctrl_, kDifOtpCtrlIrqOtpError, - &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public OtpCtrlTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_set_enabled( - nullptr, kDifOtpCtrlIrqOtpOperationDone, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_set_enabled( - &otp_ctrl_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(OTP_CTRL_INTR_ENABLE_REG_OFFSET, - {{OTP_CTRL_INTR_ENABLE_OTP_OPERATION_DONE_BIT, 0x1, true}}); - EXPECT_DIF_OK(dif_otp_ctrl_irq_set_enabled( - &otp_ctrl_, kDifOtpCtrlIrqOtpOperationDone, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(OTP_CTRL_INTR_ENABLE_REG_OFFSET, - {{OTP_CTRL_INTR_ENABLE_OTP_ERROR_BIT, 0x1, false}}); - EXPECT_DIF_OK(dif_otp_ctrl_irq_set_enabled(&otp_ctrl_, kDifOtpCtrlIrqOtpError, - irq_state)); -} - -class IrqDisableAllTest : public OtpCtrlTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_otp_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(OTP_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_otp_ctrl_irq_disable_all(&otp_ctrl_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_otp_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(OTP_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(OTP_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_otp_ctrl_irq_disable_all(&otp_ctrl_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_otp_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(OTP_CTRL_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(OTP_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_otp_ctrl_irq_disable_all(&otp_ctrl_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public OtpCtrlTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_otp_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_restore_all(&otp_ctrl_, nullptr)); - - EXPECT_DIF_BADARG(dif_otp_ctrl_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_otp_ctrl_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(OTP_CTRL_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_otp_ctrl_irq_restore_all(&otp_ctrl_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_otp_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(OTP_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_otp_ctrl_irq_restore_all(&otp_ctrl_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_otp_ctrl_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_pattgen_autogen.c b/sw/device/lib/dif/autogen/dif_pattgen_autogen.c deleted file mode 100644 index 0f619a3ed5510..0000000000000 --- a/sw/device/lib/dif/autogen/dif_pattgen_autogen.c +++ /dev/null @@ -1,265 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_pattgen_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "pattgen_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_init(mmio_region_t base_addr, dif_pattgen_t *pattgen) { - if (pattgen == NULL) { - return kDifBadArg; - } - - pattgen->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_pattgen_alert_force(const dif_pattgen_t *pattgen, - dif_pattgen_alert_t alert) { - if (pattgen == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifPattgenAlertFatalFault: - alert_idx = PATTGEN_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(pattgen->base_addr, - (ptrdiff_t)PATTGEN_ALERT_TEST_REG_OFFSET, alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool pattgen_get_irq_bit_index(dif_pattgen_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifPattgenIrqDoneCh0: - *index_out = PATTGEN_INTR_COMMON_DONE_CH0_BIT; - break; - case kDifPattgenIrqDoneCh1: - *index_out = PATTGEN_INTR_COMMON_DONE_CH1_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, - kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_get_type(const dif_pattgen_t *pattgen, - dif_pattgen_irq_t irq, - dif_irq_type_t *type) { - if (pattgen == NULL || type == NULL || irq < 0 || - irq > kDifPattgenIrqDoneCh1) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_get_state( - const dif_pattgen_t *pattgen, dif_pattgen_irq_state_snapshot_t *snapshot) { - if (pattgen == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(pattgen->base_addr, - (ptrdiff_t)PATTGEN_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, - (ptrdiff_t)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) { - if (pattgen == NULL || is_pending == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!pattgen_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - pattgen->base_addr, (ptrdiff_t)PATTGEN_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_acknowledge_all(const dif_pattgen_t *pattgen) { - if (pattgen == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(pattgen->base_addr, - (ptrdiff_t)PATTGEN_INTR_STATE_REG_OFFSET, UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_acknowledge(const dif_pattgen_t *pattgen, - dif_pattgen_irq_t irq) { - if (pattgen == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!pattgen_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(pattgen->base_addr, - (ptrdiff_t)PATTGEN_INTR_STATE_REG_OFFSET, intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_force(const dif_pattgen_t *pattgen, - dif_pattgen_irq_t irq, const bool val) { - if (pattgen == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!pattgen_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(pattgen->base_addr, - (ptrdiff_t)PATTGEN_INTR_TEST_REG_OFFSET, intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_get_enabled(const dif_pattgen_t *pattgen, - dif_pattgen_irq_t irq, - dif_toggle_t *state) { - if (pattgen == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!pattgen_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - pattgen->base_addr, (ptrdiff_t)PATTGEN_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_set_enabled(const dif_pattgen_t *pattgen, - dif_pattgen_irq_t irq, - dif_toggle_t state) { - if (pattgen == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!pattgen_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - pattgen->base_addr, (ptrdiff_t)PATTGEN_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(pattgen->base_addr, - (ptrdiff_t)PATTGEN_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_disable_all( - const dif_pattgen_t *pattgen, dif_pattgen_irq_enable_snapshot_t *snapshot) { - if (pattgen == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(pattgen->base_addr, - (ptrdiff_t)PATTGEN_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(pattgen->base_addr, - (ptrdiff_t)PATTGEN_INTR_ENABLE_REG_OFFSET, 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_restore_all( - const dif_pattgen_t *pattgen, - const dif_pattgen_irq_enable_snapshot_t *snapshot) { - if (pattgen == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(pattgen->base_addr, - (ptrdiff_t)PATTGEN_INTR_ENABLE_REG_OFFSET, *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_pattgen_autogen.h b/sw/device/lib/dif/autogen/dif_pattgen_autogen.h deleted file mode 100644 index 55ff87638a862..0000000000000 --- a/sw/device/lib/dif/autogen/dif_pattgen_autogen.h +++ /dev/null @@ -1,243 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_PATTGEN_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_PATTGEN_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief PATTGEN Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to pattgen. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_pattgen { - /** - * The base address for the pattgen hardware registers. - */ - mmio_region_t base_addr; -} dif_pattgen_t; - -/** - * Creates a new handle for a(n) pattgen peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the pattgen peripheral. - * @param[out] pattgen Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_init(mmio_region_t base_addr, dif_pattgen_t *pattgen); - -/** - * A pattgen alert type. - */ -typedef enum dif_pattgen_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifPattgenAlertFatalFault = 0, -} dif_pattgen_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param pattgen A pattgen handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_alert_force(const dif_pattgen_t *pattgen, - dif_pattgen_alert_t alert); - -/** - * A pattgen interrupt request type. - */ -typedef enum dif_pattgen_irq { - /** - * Raise if pattern generation on Channel 0 is complete - */ - kDifPattgenIrqDoneCh0 = 0, - /** - * Raise if pattern generation on Channel 1 is complete - */ - kDifPattgenIrqDoneCh1 = 1, -} dif_pattgen_irq_t; - -/** - * 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()` - * and `dif_pattgen_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_pattgen_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param pattgen A pattgen handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_get_type(const dif_pattgen_t *pattgen, - dif_pattgen_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param pattgen A pattgen handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_get_state( - const dif_pattgen_t *pattgen, dif_pattgen_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param pattgen A pattgen handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param pattgen A pattgen handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_acknowledge_all(const dif_pattgen_t *pattgen); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param pattgen A pattgen handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_acknowledge(const dif_pattgen_t *pattgen, - dif_pattgen_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param pattgen A pattgen handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_force(const dif_pattgen_t *pattgen, - dif_pattgen_irq_t irq, const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_pattgen_irq_disable_all()` and `dif_pattgen_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_pattgen_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param pattgen A pattgen handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_get_enabled(const dif_pattgen_t *pattgen, - dif_pattgen_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param pattgen A pattgen handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_set_enabled(const dif_pattgen_t *pattgen, - dif_pattgen_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param pattgen A pattgen handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_disable_all( - const dif_pattgen_t *pattgen, dif_pattgen_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param pattgen A pattgen handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pattgen_irq_restore_all( - const dif_pattgen_t *pattgen, - const dif_pattgen_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_PATTGEN_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_pattgen_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_pattgen_autogen_unittest.cc deleted file mode 100644 index 23ce2b0efb6f8..0000000000000 --- a/sw/device/lib/dif/autogen/dif_pattgen_autogen_unittest.cc +++ /dev/null @@ -1,389 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_pattgen_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "pattgen_regs.h" // Generated. - -namespace dif_pattgen_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class PattgenTest : public Test, public MmioTest { - protected: - dif_pattgen_t pattgen_ = {.base_addr = dev().region()}; -}; - -class InitTest : public PattgenTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_pattgen_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_pattgen_init(dev().region(), &pattgen_)); -} - -class AlertForceTest : public PattgenTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_pattgen_alert_force(nullptr, kDifPattgenAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_pattgen_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(PATTGEN_ALERT_TEST_REG_OFFSET, - {{PATTGEN_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_pattgen_alert_force(&pattgen_, kDifPattgenAlertFatalFault)); -} - -class IrqGetTypeTest : public PattgenTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG( - dif_pattgen_irq_get_type(nullptr, kDifPattgenIrqDoneCh0, &type)); - - EXPECT_DIF_BADARG( - dif_pattgen_irq_get_type(&pattgen_, kDifPattgenIrqDoneCh0, nullptr)); - - EXPECT_DIF_BADARG( - dif_pattgen_irq_get_type(nullptr, kDifPattgenIrqDoneCh0, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_pattgen_irq_get_type( - &pattgen_, static_cast(kDifPattgenIrqDoneCh1 + 1), - &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK( - dif_pattgen_irq_get_type(&pattgen_, kDifPattgenIrqDoneCh0, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public PattgenTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_pattgen_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_pattgen_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_pattgen_irq_get_state(&pattgen_, nullptr)); - - EXPECT_DIF_BADARG(dif_pattgen_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_pattgen_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(PATTGEN_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_pattgen_irq_get_state(&pattgen_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public PattgenTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG( - dif_pattgen_irq_is_pending(nullptr, kDifPattgenIrqDoneCh0, &is_pending)); - - EXPECT_DIF_BADARG( - dif_pattgen_irq_is_pending(&pattgen_, kDifPattgenIrqDoneCh0, nullptr)); - - EXPECT_DIF_BADARG( - dif_pattgen_irq_is_pending(nullptr, kDifPattgenIrqDoneCh0, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_pattgen_irq_is_pending( - &pattgen_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(PATTGEN_INTR_STATE_REG_OFFSET, - {{PATTGEN_INTR_STATE_DONE_CH0_BIT, true}}); - EXPECT_DIF_OK( - dif_pattgen_irq_is_pending(&pattgen_, kDifPattgenIrqDoneCh0, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(PATTGEN_INTR_STATE_REG_OFFSET, - {{PATTGEN_INTR_STATE_DONE_CH1_BIT, false}}); - EXPECT_DIF_OK( - dif_pattgen_irq_is_pending(&pattgen_, kDifPattgenIrqDoneCh1, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 2; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_pattgen_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(PATTGEN_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_pattgen_irq_acknowledge_all(&pattgen_)); -} - -class IrqAcknowledgeTest : public PattgenTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_pattgen_irq_acknowledge(nullptr, kDifPattgenIrqDoneCh0)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_pattgen_irq_acknowledge(nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(PATTGEN_INTR_STATE_REG_OFFSET, - {{PATTGEN_INTR_STATE_DONE_CH0_BIT, true}}); - EXPECT_DIF_OK(dif_pattgen_irq_acknowledge(&pattgen_, kDifPattgenIrqDoneCh0)); - - // Clear the last IRQ state. - EXPECT_WRITE32(PATTGEN_INTR_STATE_REG_OFFSET, - {{PATTGEN_INTR_STATE_DONE_CH1_BIT, true}}); - EXPECT_DIF_OK(dif_pattgen_irq_acknowledge(&pattgen_, kDifPattgenIrqDoneCh1)); -} - -class IrqForceTest : public PattgenTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_pattgen_irq_force(nullptr, kDifPattgenIrqDoneCh0, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_pattgen_irq_force(nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(PATTGEN_INTR_TEST_REG_OFFSET, - {{PATTGEN_INTR_TEST_DONE_CH0_BIT, true}}); - EXPECT_DIF_OK(dif_pattgen_irq_force(&pattgen_, kDifPattgenIrqDoneCh0, true)); - - // Force last IRQ. - EXPECT_WRITE32(PATTGEN_INTR_TEST_REG_OFFSET, - {{PATTGEN_INTR_TEST_DONE_CH1_BIT, true}}); - EXPECT_DIF_OK(dif_pattgen_irq_force(&pattgen_, kDifPattgenIrqDoneCh1, true)); -} - -class IrqGetEnabledTest : public PattgenTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG( - dif_pattgen_irq_get_enabled(nullptr, kDifPattgenIrqDoneCh0, &irq_state)); - - EXPECT_DIF_BADARG( - dif_pattgen_irq_get_enabled(&pattgen_, kDifPattgenIrqDoneCh0, nullptr)); - - EXPECT_DIF_BADARG( - dif_pattgen_irq_get_enabled(nullptr, kDifPattgenIrqDoneCh0, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_pattgen_irq_get_enabled( - &pattgen_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(PATTGEN_INTR_ENABLE_REG_OFFSET, - {{PATTGEN_INTR_ENABLE_DONE_CH0_BIT, true}}); - EXPECT_DIF_OK(dif_pattgen_irq_get_enabled(&pattgen_, kDifPattgenIrqDoneCh0, - &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(PATTGEN_INTR_ENABLE_REG_OFFSET, - {{PATTGEN_INTR_ENABLE_DONE_CH1_BIT, false}}); - EXPECT_DIF_OK(dif_pattgen_irq_get_enabled(&pattgen_, kDifPattgenIrqDoneCh1, - &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public PattgenTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG( - dif_pattgen_irq_set_enabled(nullptr, kDifPattgenIrqDoneCh0, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_pattgen_irq_set_enabled( - &pattgen_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(PATTGEN_INTR_ENABLE_REG_OFFSET, - {{PATTGEN_INTR_ENABLE_DONE_CH0_BIT, 0x1, true}}); - EXPECT_DIF_OK( - dif_pattgen_irq_set_enabled(&pattgen_, kDifPattgenIrqDoneCh0, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(PATTGEN_INTR_ENABLE_REG_OFFSET, - {{PATTGEN_INTR_ENABLE_DONE_CH1_BIT, 0x1, false}}); - EXPECT_DIF_OK( - dif_pattgen_irq_set_enabled(&pattgen_, kDifPattgenIrqDoneCh1, irq_state)); -} - -class IrqDisableAllTest : public PattgenTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_pattgen_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_pattgen_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_pattgen_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(PATTGEN_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_pattgen_irq_disable_all(&pattgen_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_pattgen_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(PATTGEN_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(PATTGEN_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_pattgen_irq_disable_all(&pattgen_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_pattgen_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(PATTGEN_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(PATTGEN_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_pattgen_irq_disable_all(&pattgen_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public PattgenTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_pattgen_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_pattgen_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_pattgen_irq_restore_all(&pattgen_, nullptr)); - - EXPECT_DIF_BADARG(dif_pattgen_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_pattgen_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(PATTGEN_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_pattgen_irq_restore_all(&pattgen_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_pattgen_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(PATTGEN_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_pattgen_irq_restore_all(&pattgen_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_pattgen_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_pinmux_autogen.c b/sw/device/lib/dif/autogen/dif_pinmux_autogen.c deleted file mode 100644 index a9d740e291498..0000000000000 --- a/sw/device/lib/dif/autogen/dif_pinmux_autogen.c +++ /dev/null @@ -1,47 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_pinmux_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "pinmux_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pinmux_init(mmio_region_t base_addr, dif_pinmux_t *pinmux) { - if (pinmux == NULL) { - return kDifBadArg; - } - - pinmux->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_pinmux_alert_force(const dif_pinmux_t *pinmux, - dif_pinmux_alert_t alert) { - if (pinmux == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifPinmuxAlertFatalFault: - alert_idx = PINMUX_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(pinmux->base_addr, - (ptrdiff_t)PINMUX_ALERT_TEST_REG_OFFSET, alert_test_reg); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_pinmux_autogen.h b/sw/device/lib/dif/autogen/dif_pinmux_autogen.h deleted file mode 100644 index 1b7ae68ac5da8..0000000000000 --- a/sw/device/lib/dif/autogen/dif_pinmux_autogen.h +++ /dev/null @@ -1,78 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_PINMUX_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_PINMUX_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief PINMUX Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to pinmux. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_pinmux { - /** - * The base address for the pinmux hardware registers. - */ - mmio_region_t base_addr; -} dif_pinmux_t; - -/** - * Creates a new handle for a(n) pinmux peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the pinmux peripheral. - * @param[out] pinmux Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pinmux_init(mmio_region_t base_addr, dif_pinmux_t *pinmux); - -/** - * A pinmux alert type. - */ -typedef enum dif_pinmux_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifPinmuxAlertFatalFault = 0, -} dif_pinmux_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param pinmux A pinmux handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pinmux_alert_force(const dif_pinmux_t *pinmux, - dif_pinmux_alert_t alert); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_PINMUX_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_pinmux_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_pinmux_autogen_unittest.cc deleted file mode 100644 index 6005fcad0d4e1..0000000000000 --- a/sw/device/lib/dif/autogen/dif_pinmux_autogen_unittest.cc +++ /dev/null @@ -1,58 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_pinmux_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "pinmux_regs.h" // Generated. - -namespace dif_pinmux_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class PinmuxTest : public Test, public MmioTest { - protected: - dif_pinmux_t pinmux_ = {.base_addr = dev().region()}; -}; - -class InitTest : public PinmuxTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_pinmux_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_pinmux_init(dev().region(), &pinmux_)); -} - -class AlertForceTest : public PinmuxTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_pinmux_alert_force(nullptr, kDifPinmuxAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_pinmux_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(PINMUX_ALERT_TEST_REG_OFFSET, - {{PINMUX_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_pinmux_alert_force(&pinmux_, kDifPinmuxAlertFatalFault)); -} - -} // namespace -} // namespace dif_pinmux_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_pwm_autogen.c b/sw/device/lib/dif/autogen/dif_pwm_autogen.c deleted file mode 100644 index 504c6c40df468..0000000000000 --- a/sw/device/lib/dif/autogen/dif_pwm_autogen.c +++ /dev/null @@ -1,46 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_pwm_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "pwm_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwm_init(mmio_region_t base_addr, dif_pwm_t *pwm) { - if (pwm == NULL) { - return kDifBadArg; - } - - pwm->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_pwm_alert_force(const dif_pwm_t *pwm, dif_pwm_alert_t alert) { - if (pwm == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifPwmAlertFatalFault: - alert_idx = PWM_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(pwm->base_addr, (ptrdiff_t)PWM_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_pwm_autogen.h b/sw/device/lib/dif/autogen/dif_pwm_autogen.h deleted file mode 100644 index 30e3d90f7ffea..0000000000000 --- a/sw/device/lib/dif/autogen/dif_pwm_autogen.h +++ /dev/null @@ -1,77 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_PWM_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_PWM_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief PWM Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to pwm. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_pwm { - /** - * The base address for the pwm hardware registers. - */ - mmio_region_t base_addr; -} dif_pwm_t; - -/** - * Creates a new handle for a(n) pwm peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the pwm peripheral. - * @param[out] pwm Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwm_init(mmio_region_t base_addr, dif_pwm_t *pwm); - -/** - * A pwm alert type. - */ -typedef enum dif_pwm_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifPwmAlertFatalFault = 0, -} dif_pwm_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param pwm A pwm handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwm_alert_force(const dif_pwm_t *pwm, dif_pwm_alert_t alert); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_PWM_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_pwm_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_pwm_autogen_unittest.cc deleted file mode 100644 index d6aaf57f0b9b4..0000000000000 --- a/sw/device/lib/dif/autogen/dif_pwm_autogen_unittest.cc +++ /dev/null @@ -1,58 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_pwm_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "pwm_regs.h" // Generated. - -namespace dif_pwm_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class PwmTest : public Test, public MmioTest { - protected: - dif_pwm_t pwm_ = {.base_addr = dev().region()}; -}; - -class InitTest : public PwmTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_pwm_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_pwm_init(dev().region(), &pwm_)); -} - -class AlertForceTest : public PwmTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_pwm_alert_force(nullptr, kDifPwmAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_pwm_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(PWM_ALERT_TEST_REG_OFFSET, - {{PWM_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_pwm_alert_force(&pwm_, kDifPwmAlertFatalFault)); -} - -} // namespace -} // namespace dif_pwm_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_pwrmgr_autogen.c b/sw/device/lib/dif/autogen/dif_pwrmgr_autogen.c deleted file mode 100644 index 5f34c6f310893..0000000000000 --- a/sw/device/lib/dif/autogen/dif_pwrmgr_autogen.c +++ /dev/null @@ -1,259 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_pwrmgr_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "pwrmgr_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_init(mmio_region_t base_addr, dif_pwrmgr_t *pwrmgr) { - if (pwrmgr == NULL) { - return kDifBadArg; - } - - pwrmgr->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_pwrmgr_alert_force(const dif_pwrmgr_t *pwrmgr, - dif_pwrmgr_alert_t alert) { - if (pwrmgr == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifPwrmgrAlertFatalFault: - alert_idx = PWRMGR_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(pwrmgr->base_addr, - (ptrdiff_t)PWRMGR_ALERT_TEST_REG_OFFSET, alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool pwrmgr_get_irq_bit_index(dif_pwrmgr_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifPwrmgrIrqWakeup: - *index_out = PWRMGR_INTR_COMMON_WAKEUP_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_get_type(const dif_pwrmgr_t *pwrmgr, - dif_pwrmgr_irq_t irq, - dif_irq_type_t *type) { - if (pwrmgr == NULL || type == NULL || irq < 0 || irq > kDifPwrmgrIrqWakeup) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_get_state( - const dif_pwrmgr_t *pwrmgr, dif_pwrmgr_irq_state_snapshot_t *snapshot) { - if (pwrmgr == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(pwrmgr->base_addr, - (ptrdiff_t)PWRMGR_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, - (ptrdiff_t)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) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!pwrmgr_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - pwrmgr->base_addr, (ptrdiff_t)PWRMGR_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_acknowledge_all(const dif_pwrmgr_t *pwrmgr) { - if (pwrmgr == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(pwrmgr->base_addr, - (ptrdiff_t)PWRMGR_INTR_STATE_REG_OFFSET, UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_acknowledge(const dif_pwrmgr_t *pwrmgr, - dif_pwrmgr_irq_t irq) { - if (pwrmgr == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!pwrmgr_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(pwrmgr->base_addr, - (ptrdiff_t)PWRMGR_INTR_STATE_REG_OFFSET, intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_force(const dif_pwrmgr_t *pwrmgr, - dif_pwrmgr_irq_t irq, const bool val) { - if (pwrmgr == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!pwrmgr_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(pwrmgr->base_addr, (ptrdiff_t)PWRMGR_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_get_enabled(const dif_pwrmgr_t *pwrmgr, - dif_pwrmgr_irq_t irq, - dif_toggle_t *state) { - if (pwrmgr == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!pwrmgr_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - pwrmgr->base_addr, (ptrdiff_t)PWRMGR_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_set_enabled(const dif_pwrmgr_t *pwrmgr, - dif_pwrmgr_irq_t irq, - dif_toggle_t state) { - if (pwrmgr == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!pwrmgr_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - pwrmgr->base_addr, (ptrdiff_t)PWRMGR_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(pwrmgr->base_addr, - (ptrdiff_t)PWRMGR_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_disable_all( - const dif_pwrmgr_t *pwrmgr, dif_pwrmgr_irq_enable_snapshot_t *snapshot) { - if (pwrmgr == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(pwrmgr->base_addr, - (ptrdiff_t)PWRMGR_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(pwrmgr->base_addr, - (ptrdiff_t)PWRMGR_INTR_ENABLE_REG_OFFSET, 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_restore_all( - const dif_pwrmgr_t *pwrmgr, - const dif_pwrmgr_irq_enable_snapshot_t *snapshot) { - if (pwrmgr == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(pwrmgr->base_addr, - (ptrdiff_t)PWRMGR_INTR_ENABLE_REG_OFFSET, *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_pwrmgr_autogen.h b/sw/device/lib/dif/autogen/dif_pwrmgr_autogen.h deleted file mode 100644 index 0d009b6ec4a49..0000000000000 --- a/sw/device/lib/dif/autogen/dif_pwrmgr_autogen.h +++ /dev/null @@ -1,238 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_PWRMGR_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_PWRMGR_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief PWRMGR Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to pwrmgr. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_pwrmgr { - /** - * The base address for the pwrmgr hardware registers. - */ - mmio_region_t base_addr; -} dif_pwrmgr_t; - -/** - * Creates a new handle for a(n) pwrmgr peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the pwrmgr peripheral. - * @param[out] pwrmgr Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_init(mmio_region_t base_addr, dif_pwrmgr_t *pwrmgr); - -/** - * A pwrmgr alert type. - */ -typedef enum dif_pwrmgr_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifPwrmgrAlertFatalFault = 0, -} dif_pwrmgr_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param pwrmgr A pwrmgr handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_alert_force(const dif_pwrmgr_t *pwrmgr, - dif_pwrmgr_alert_t alert); - -/** - * A pwrmgr interrupt request type. - */ -typedef enum dif_pwrmgr_irq { - /** - * Wake from low power state. See wake info for more details - */ - kDifPwrmgrIrqWakeup = 0, -} dif_pwrmgr_irq_t; - -/** - * 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()` - * and `dif_pwrmgr_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_pwrmgr_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param pwrmgr A pwrmgr handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_get_type(const dif_pwrmgr_t *pwrmgr, - dif_pwrmgr_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param pwrmgr A pwrmgr handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_get_state( - const dif_pwrmgr_t *pwrmgr, dif_pwrmgr_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param pwrmgr A pwrmgr handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param pwrmgr A pwrmgr handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_acknowledge_all(const dif_pwrmgr_t *pwrmgr); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param pwrmgr A pwrmgr handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_acknowledge(const dif_pwrmgr_t *pwrmgr, - dif_pwrmgr_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param pwrmgr A pwrmgr handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_force(const dif_pwrmgr_t *pwrmgr, - dif_pwrmgr_irq_t irq, const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_pwrmgr_irq_disable_all()` and `dif_pwrmgr_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_pwrmgr_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param pwrmgr A pwrmgr handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_get_enabled(const dif_pwrmgr_t *pwrmgr, - dif_pwrmgr_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param pwrmgr A pwrmgr handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_set_enabled(const dif_pwrmgr_t *pwrmgr, - dif_pwrmgr_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param pwrmgr A pwrmgr handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_disable_all( - const dif_pwrmgr_t *pwrmgr, dif_pwrmgr_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param pwrmgr A pwrmgr handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_pwrmgr_irq_restore_all( - const dif_pwrmgr_t *pwrmgr, - const dif_pwrmgr_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_PWRMGR_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_pwrmgr_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_pwrmgr_autogen_unittest.cc deleted file mode 100644 index 79fb108c065a6..0000000000000 --- a/sw/device/lib/dif/autogen/dif_pwrmgr_autogen_unittest.cc +++ /dev/null @@ -1,351 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_pwrmgr_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "pwrmgr_regs.h" // Generated. - -namespace dif_pwrmgr_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class PwrmgrTest : public Test, public MmioTest { - protected: - dif_pwrmgr_t pwrmgr_ = {.base_addr = dev().region()}; -}; - -class InitTest : public PwrmgrTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_pwrmgr_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_pwrmgr_init(dev().region(), &pwrmgr_)); -} - -class AlertForceTest : public PwrmgrTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_pwrmgr_alert_force(nullptr, kDifPwrmgrAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_pwrmgr_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(PWRMGR_ALERT_TEST_REG_OFFSET, - {{PWRMGR_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_pwrmgr_alert_force(&pwrmgr_, kDifPwrmgrAlertFatalFault)); -} - -class IrqGetTypeTest : public PwrmgrTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG( - dif_pwrmgr_irq_get_type(nullptr, kDifPwrmgrIrqWakeup, &type)); - - EXPECT_DIF_BADARG( - dif_pwrmgr_irq_get_type(&pwrmgr_, kDifPwrmgrIrqWakeup, nullptr)); - - EXPECT_DIF_BADARG( - dif_pwrmgr_irq_get_type(nullptr, kDifPwrmgrIrqWakeup, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_pwrmgr_irq_get_type( - &pwrmgr_, static_cast(kDifPwrmgrIrqWakeup + 1), &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_pwrmgr_irq_get_type(&pwrmgr_, kDifPwrmgrIrqWakeup, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public PwrmgrTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_pwrmgr_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_pwrmgr_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_pwrmgr_irq_get_state(&pwrmgr_, nullptr)); - - EXPECT_DIF_BADARG(dif_pwrmgr_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_pwrmgr_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(PWRMGR_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_pwrmgr_irq_get_state(&pwrmgr_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public PwrmgrTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG( - dif_pwrmgr_irq_is_pending(nullptr, kDifPwrmgrIrqWakeup, &is_pending)); - - EXPECT_DIF_BADARG( - dif_pwrmgr_irq_is_pending(&pwrmgr_, kDifPwrmgrIrqWakeup, nullptr)); - - EXPECT_DIF_BADARG( - dif_pwrmgr_irq_is_pending(nullptr, kDifPwrmgrIrqWakeup, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_pwrmgr_irq_is_pending( - &pwrmgr_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(PWRMGR_INTR_STATE_REG_OFFSET, - {{PWRMGR_INTR_STATE_WAKEUP_BIT, true}}); - EXPECT_DIF_OK( - dif_pwrmgr_irq_is_pending(&pwrmgr_, kDifPwrmgrIrqWakeup, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 1; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_pwrmgr_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(PWRMGR_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_pwrmgr_irq_acknowledge_all(&pwrmgr_)); -} - -class IrqAcknowledgeTest : public PwrmgrTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG(dif_pwrmgr_irq_acknowledge(nullptr, kDifPwrmgrIrqWakeup)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_pwrmgr_irq_acknowledge(nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(PWRMGR_INTR_STATE_REG_OFFSET, - {{PWRMGR_INTR_STATE_WAKEUP_BIT, true}}); - EXPECT_DIF_OK(dif_pwrmgr_irq_acknowledge(&pwrmgr_, kDifPwrmgrIrqWakeup)); -} - -class IrqForceTest : public PwrmgrTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_pwrmgr_irq_force(nullptr, kDifPwrmgrIrqWakeup, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_pwrmgr_irq_force(nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(PWRMGR_INTR_TEST_REG_OFFSET, - {{PWRMGR_INTR_TEST_WAKEUP_BIT, true}}); - EXPECT_DIF_OK(dif_pwrmgr_irq_force(&pwrmgr_, kDifPwrmgrIrqWakeup, true)); -} - -class IrqGetEnabledTest : public PwrmgrTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG( - dif_pwrmgr_irq_get_enabled(nullptr, kDifPwrmgrIrqWakeup, &irq_state)); - - EXPECT_DIF_BADARG( - dif_pwrmgr_irq_get_enabled(&pwrmgr_, kDifPwrmgrIrqWakeup, nullptr)); - - EXPECT_DIF_BADARG( - dif_pwrmgr_irq_get_enabled(nullptr, kDifPwrmgrIrqWakeup, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_pwrmgr_irq_get_enabled( - &pwrmgr_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(PWRMGR_INTR_ENABLE_REG_OFFSET, - {{PWRMGR_INTR_ENABLE_WAKEUP_BIT, true}}); - EXPECT_DIF_OK( - dif_pwrmgr_irq_get_enabled(&pwrmgr_, kDifPwrmgrIrqWakeup, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); -} - -class IrqSetEnabledTest : public PwrmgrTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG( - dif_pwrmgr_irq_set_enabled(nullptr, kDifPwrmgrIrqWakeup, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_pwrmgr_irq_set_enabled( - &pwrmgr_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(PWRMGR_INTR_ENABLE_REG_OFFSET, - {{PWRMGR_INTR_ENABLE_WAKEUP_BIT, 0x1, true}}); - EXPECT_DIF_OK( - dif_pwrmgr_irq_set_enabled(&pwrmgr_, kDifPwrmgrIrqWakeup, irq_state)); -} - -class IrqDisableAllTest : public PwrmgrTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_pwrmgr_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_pwrmgr_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_pwrmgr_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(PWRMGR_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_pwrmgr_irq_disable_all(&pwrmgr_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_pwrmgr_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(PWRMGR_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(PWRMGR_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_pwrmgr_irq_disable_all(&pwrmgr_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_pwrmgr_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(PWRMGR_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(PWRMGR_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_pwrmgr_irq_disable_all(&pwrmgr_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public PwrmgrTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_pwrmgr_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_pwrmgr_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_pwrmgr_irq_restore_all(&pwrmgr_, nullptr)); - - EXPECT_DIF_BADARG(dif_pwrmgr_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_pwrmgr_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(PWRMGR_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_pwrmgr_irq_restore_all(&pwrmgr_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_pwrmgr_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(PWRMGR_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_pwrmgr_irq_restore_all(&pwrmgr_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_pwrmgr_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_rom_ctrl_autogen.c b/sw/device/lib/dif/autogen/dif_rom_ctrl_autogen.c deleted file mode 100644 index d3d04bf6d50af..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rom_ctrl_autogen.c +++ /dev/null @@ -1,49 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_rom_ctrl_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "rom_ctrl_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_rom_ctrl_init(mmio_region_t base_addr, - dif_rom_ctrl_t *rom_ctrl) { - if (rom_ctrl == NULL) { - return kDifBadArg; - } - - rom_ctrl->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_rom_ctrl_alert_force(const dif_rom_ctrl_t *rom_ctrl, - dif_rom_ctrl_alert_t alert) { - if (rom_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifRomCtrlAlertFatal: - alert_idx = ROM_CTRL_ALERT_TEST_FATAL_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(rom_ctrl->base_addr, - (ptrdiff_t)ROM_CTRL_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_rom_ctrl_autogen.h b/sw/device/lib/dif/autogen/dif_rom_ctrl_autogen.h deleted file mode 100644 index 1c34194717fd6..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rom_ctrl_autogen.h +++ /dev/null @@ -1,80 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_ROM_CTRL_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_ROM_CTRL_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief ROM_CTRL Device Interface - * Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to rom_ctrl. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_rom_ctrl { - /** - * The base address for the rom_ctrl hardware registers. - */ - mmio_region_t base_addr; -} dif_rom_ctrl_t; - -/** - * Creates a new handle for a(n) rom_ctrl peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the rom_ctrl peripheral. - * @param[out] rom_ctrl Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rom_ctrl_init(mmio_region_t base_addr, - dif_rom_ctrl_t *rom_ctrl); - -/** - * A rom_ctrl alert type. - */ -typedef enum dif_rom_ctrl_alert { - /** - * A fatal error. Fatal alerts are non-recoverable and will be asserted until - * a hard reset. - */ - kDifRomCtrlAlertFatal = 0, -} dif_rom_ctrl_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param rom_ctrl A rom_ctrl handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rom_ctrl_alert_force(const dif_rom_ctrl_t *rom_ctrl, - dif_rom_ctrl_alert_t alert); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_ROM_CTRL_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_rom_ctrl_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_rom_ctrl_autogen_unittest.cc deleted file mode 100644 index dfb627ec47ff1..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rom_ctrl_autogen_unittest.cc +++ /dev/null @@ -1,58 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_rom_ctrl_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "rom_ctrl_regs.h" // Generated. - -namespace dif_rom_ctrl_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class RomCtrlTest : public Test, public MmioTest { - protected: - dif_rom_ctrl_t rom_ctrl_ = {.base_addr = dev().region()}; -}; - -class InitTest : public RomCtrlTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_rom_ctrl_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_rom_ctrl_init(dev().region(), &rom_ctrl_)); -} - -class AlertForceTest : public RomCtrlTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_rom_ctrl_alert_force(nullptr, kDifRomCtrlAlertFatal)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_rom_ctrl_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(ROM_CTRL_ALERT_TEST_REG_OFFSET, - {{ROM_CTRL_ALERT_TEST_FATAL_BIT, true}}); - EXPECT_DIF_OK(dif_rom_ctrl_alert_force(&rom_ctrl_, kDifRomCtrlAlertFatal)); -} - -} // namespace -} // namespace dif_rom_ctrl_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_rstmgr_autogen.c b/sw/device/lib/dif/autogen/dif_rstmgr_autogen.c deleted file mode 100644 index 010a54a4a8480..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rstmgr_autogen.c +++ /dev/null @@ -1,50 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_rstmgr_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "rstmgr_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_rstmgr_init(mmio_region_t base_addr, dif_rstmgr_t *rstmgr) { - if (rstmgr == NULL) { - return kDifBadArg; - } - - rstmgr->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_rstmgr_alert_force(const dif_rstmgr_t *rstmgr, - dif_rstmgr_alert_t alert) { - if (rstmgr == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifRstmgrAlertFatalFault: - alert_idx = RSTMGR_ALERT_TEST_FATAL_FAULT_BIT; - break; - case kDifRstmgrAlertFatalCnstyFault: - alert_idx = RSTMGR_ALERT_TEST_FATAL_CNSTY_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(rstmgr->base_addr, - (ptrdiff_t)RSTMGR_ALERT_TEST_REG_OFFSET, alert_test_reg); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_rstmgr_autogen.h b/sw/device/lib/dif/autogen/dif_rstmgr_autogen.h deleted file mode 100644 index ab58c1ae8992f..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rstmgr_autogen.h +++ /dev/null @@ -1,85 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_RSTMGR_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_RSTMGR_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief RSTMGR Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to rstmgr. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_rstmgr { - /** - * The base address for the rstmgr hardware registers. - */ - mmio_region_t base_addr; -} dif_rstmgr_t; - -/** - * Creates a new handle for a(n) rstmgr peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the rstmgr peripheral. - * @param[out] rstmgr Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rstmgr_init(mmio_region_t base_addr, dif_rstmgr_t *rstmgr); - -/** - * A rstmgr alert type. - */ -typedef enum dif_rstmgr_alert { - /** - * This fatal alert is triggered when a fatal structural fault is detected. - * Structural faults include errors such as sparse fsm errors and tlul - * integrity errors. - */ - kDifRstmgrAlertFatalFault = 0, - /** - * This fatal alert is triggered when a reset consistency fault is detected. - * It is separated from the category above for clearer error collection and - * debug. - */ - kDifRstmgrAlertFatalCnstyFault = 1, -} dif_rstmgr_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param rstmgr A rstmgr handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rstmgr_alert_force(const dif_rstmgr_t *rstmgr, - dif_rstmgr_alert_t alert); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_RSTMGR_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_rstmgr_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_rstmgr_autogen_unittest.cc deleted file mode 100644 index 7db097b084abe..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rstmgr_autogen_unittest.cc +++ /dev/null @@ -1,64 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_rstmgr_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "rstmgr_regs.h" // Generated. - -namespace dif_rstmgr_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class RstmgrTest : public Test, public MmioTest { - protected: - dif_rstmgr_t rstmgr_ = {.base_addr = dev().region()}; -}; - -class InitTest : public RstmgrTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_rstmgr_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_rstmgr_init(dev().region(), &rstmgr_)); -} - -class AlertForceTest : public RstmgrTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_rstmgr_alert_force(nullptr, kDifRstmgrAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_rstmgr_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(RSTMGR_ALERT_TEST_REG_OFFSET, - {{RSTMGR_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_rstmgr_alert_force(&rstmgr_, kDifRstmgrAlertFatalFault)); - - // Force last alert. - EXPECT_WRITE32(RSTMGR_ALERT_TEST_REG_OFFSET, - {{RSTMGR_ALERT_TEST_FATAL_CNSTY_FAULT_BIT, true}}); - EXPECT_DIF_OK( - dif_rstmgr_alert_force(&rstmgr_, kDifRstmgrAlertFatalCnstyFault)); -} - -} // namespace -} // namespace dif_rstmgr_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_rv_core_ibex_autogen.c b/sw/device/lib/dif/autogen/dif_rv_core_ibex_autogen.c deleted file mode 100644 index 04dae04fd77d9..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rv_core_ibex_autogen.c +++ /dev/null @@ -1,58 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_rv_core_ibex_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "rv_core_ibex_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_core_ibex_init(mmio_region_t base_addr, - dif_rv_core_ibex_t *rv_core_ibex) { - if (rv_core_ibex == NULL) { - return kDifBadArg; - } - - rv_core_ibex->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_rv_core_ibex_alert_force( - const dif_rv_core_ibex_t *rv_core_ibex, dif_rv_core_ibex_alert_t alert) { - if (rv_core_ibex == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifRvCoreIbexAlertFatalSwErr: - alert_idx = RV_CORE_IBEX_ALERT_TEST_FATAL_SW_ERR_BIT; - break; - case kDifRvCoreIbexAlertRecovSwErr: - alert_idx = RV_CORE_IBEX_ALERT_TEST_RECOV_SW_ERR_BIT; - break; - case kDifRvCoreIbexAlertFatalHwErr: - alert_idx = RV_CORE_IBEX_ALERT_TEST_FATAL_HW_ERR_BIT; - break; - case kDifRvCoreIbexAlertRecovHwErr: - alert_idx = RV_CORE_IBEX_ALERT_TEST_RECOV_HW_ERR_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(rv_core_ibex->base_addr, - (ptrdiff_t)RV_CORE_IBEX_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_rv_core_ibex_autogen.h b/sw/device/lib/dif/autogen/dif_rv_core_ibex_autogen.h deleted file mode 100644 index 3df5f8f48fbca..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rv_core_ibex_autogen.h +++ /dev/null @@ -1,93 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_RV_CORE_IBEX_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_RV_CORE_IBEX_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief RV_CORE_IBEX Device Interface - * Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to rv_core_ibex. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_rv_core_ibex { - /** - * The base address for the rv_core_ibex hardware registers. - */ - mmio_region_t base_addr; -} dif_rv_core_ibex_t; - -/** - * Creates a new handle for a(n) rv_core_ibex peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the rv_core_ibex peripheral. - * @param[out] rv_core_ibex Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_core_ibex_init(mmio_region_t base_addr, - dif_rv_core_ibex_t *rv_core_ibex); - -/** - * A rv_core_ibex alert type. - */ -typedef enum dif_rv_core_ibex_alert { - /** - * Software triggered alert for fatal faults - */ - kDifRvCoreIbexAlertFatalSwErr = 0, - /** - * Software triggered Alert for recoverable faults - */ - kDifRvCoreIbexAlertRecovSwErr = 1, - /** - * Triggered when - Ibex raises `alert_major_internal_o` - Ibex raises - * `alert_major_bus_o` - A double fault is seen (Ibex raises - * `double_fault_seen_o`) - A bus integrity error is seen - */ - kDifRvCoreIbexAlertFatalHwErr = 2, - /** - * Triggered when Ibex raises `alert_minor_o` - */ - kDifRvCoreIbexAlertRecovHwErr = 3, -} dif_rv_core_ibex_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param rv_core_ibex A rv_core_ibex handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_core_ibex_alert_force( - const dif_rv_core_ibex_t *rv_core_ibex, dif_rv_core_ibex_alert_t alert); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_RV_CORE_IBEX_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_rv_core_ibex_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_rv_core_ibex_autogen_unittest.cc deleted file mode 100644 index 3cca27b9f81f1..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rv_core_ibex_autogen_unittest.cc +++ /dev/null @@ -1,66 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_rv_core_ibex_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "rv_core_ibex_regs.h" // Generated. - -namespace dif_rv_core_ibex_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class RvCoreIbexTest : public Test, public MmioTest { - protected: - dif_rv_core_ibex_t rv_core_ibex_ = {.base_addr = dev().region()}; -}; - -class InitTest : public RvCoreIbexTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_rv_core_ibex_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_rv_core_ibex_init(dev().region(), &rv_core_ibex_)); -} - -class AlertForceTest : public RvCoreIbexTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_rv_core_ibex_alert_force(nullptr, kDifRvCoreIbexAlertFatalSwErr)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG(dif_rv_core_ibex_alert_force( - nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(RV_CORE_IBEX_ALERT_TEST_REG_OFFSET, - {{RV_CORE_IBEX_ALERT_TEST_FATAL_SW_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_rv_core_ibex_alert_force(&rv_core_ibex_, - kDifRvCoreIbexAlertFatalSwErr)); - - // Force last alert. - EXPECT_WRITE32(RV_CORE_IBEX_ALERT_TEST_REG_OFFSET, - {{RV_CORE_IBEX_ALERT_TEST_RECOV_HW_ERR_BIT, true}}); - EXPECT_DIF_OK(dif_rv_core_ibex_alert_force(&rv_core_ibex_, - kDifRvCoreIbexAlertRecovHwErr)); -} - -} // namespace -} // namespace dif_rv_core_ibex_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_rv_dm_autogen.c b/sw/device/lib/dif/autogen/dif_rv_dm_autogen.c deleted file mode 100644 index 8aad79aa5b0c1..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rv_dm_autogen.c +++ /dev/null @@ -1,47 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_rv_dm_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "rv_dm_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_dm_init(mmio_region_t base_addr, dif_rv_dm_t *rv_dm) { - if (rv_dm == NULL) { - return kDifBadArg; - } - - rv_dm->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_rv_dm_alert_force(const dif_rv_dm_t *rv_dm, - dif_rv_dm_alert_t alert) { - if (rv_dm == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifRvDmAlertFatalFault: - alert_idx = RV_DM_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(rv_dm->base_addr, (ptrdiff_t)RV_DM_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_rv_dm_autogen.h b/sw/device/lib/dif/autogen/dif_rv_dm_autogen.h deleted file mode 100644 index e092960a1acef..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rv_dm_autogen.h +++ /dev/null @@ -1,78 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_RV_DM_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_RV_DM_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief RV_DM Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to rv_dm. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_rv_dm { - /** - * The base address for the rv_dm hardware registers. - */ - mmio_region_t base_addr; -} dif_rv_dm_t; - -/** - * Creates a new handle for a(n) rv_dm peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the rv_dm peripheral. - * @param[out] rv_dm Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_dm_init(mmio_region_t base_addr, dif_rv_dm_t *rv_dm); - -/** - * A rv_dm alert type. - */ -typedef enum dif_rv_dm_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifRvDmAlertFatalFault = 0, -} dif_rv_dm_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param rv_dm A rv_dm handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_dm_alert_force(const dif_rv_dm_t *rv_dm, - dif_rv_dm_alert_t alert); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_RV_DM_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_rv_dm_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_rv_dm_autogen_unittest.cc deleted file mode 100644 index 9674acf2e1862..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rv_dm_autogen_unittest.cc +++ /dev/null @@ -1,58 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_rv_dm_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "rv_dm_regs.h" // Generated. - -namespace dif_rv_dm_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class RvDmTest : public Test, public MmioTest { - protected: - dif_rv_dm_t rv_dm_ = {.base_addr = dev().region()}; -}; - -class InitTest : public RvDmTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_rv_dm_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_rv_dm_init(dev().region(), &rv_dm_)); -} - -class AlertForceTest : public RvDmTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_rv_dm_alert_force(nullptr, kDifRvDmAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_rv_dm_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(RV_DM_ALERT_TEST_REG_OFFSET, - {{RV_DM_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_rv_dm_alert_force(&rv_dm_, kDifRvDmAlertFatalFault)); -} - -} // namespace -} // namespace dif_rv_dm_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_rv_plic_autogen.c b/sw/device/lib/dif/autogen/dif_rv_plic_autogen.c deleted file mode 100644 index 970bc8010e0a7..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rv_plic_autogen.c +++ /dev/null @@ -1,47 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_rv_plic_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "rv_plic_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_plic_init(mmio_region_t base_addr, dif_rv_plic_t *rv_plic) { - if (rv_plic == NULL) { - return kDifBadArg; - } - - rv_plic->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_rv_plic_alert_force(const dif_rv_plic_t *rv_plic, - dif_rv_plic_alert_t alert) { - if (rv_plic == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifRvPlicAlertFatalFault: - alert_idx = RV_PLIC_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(rv_plic->base_addr, - (ptrdiff_t)RV_PLIC_ALERT_TEST_REG_OFFSET, alert_test_reg); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_rv_plic_autogen.h b/sw/device/lib/dif/autogen/dif_rv_plic_autogen.h deleted file mode 100644 index 939cfd6812dda..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rv_plic_autogen.h +++ /dev/null @@ -1,78 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_RV_PLIC_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_RV_PLIC_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief RV_PLIC Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to rv_plic. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_rv_plic { - /** - * The base address for the rv_plic hardware registers. - */ - mmio_region_t base_addr; -} dif_rv_plic_t; - -/** - * Creates a new handle for a(n) rv_plic peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the rv_plic peripheral. - * @param[out] rv_plic Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_plic_init(mmio_region_t base_addr, dif_rv_plic_t *rv_plic); - -/** - * A rv_plic alert type. - */ -typedef enum dif_rv_plic_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifRvPlicAlertFatalFault = 0, -} dif_rv_plic_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param rv_plic A rv_plic handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_plic_alert_force(const dif_rv_plic_t *rv_plic, - dif_rv_plic_alert_t alert); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_RV_PLIC_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_rv_plic_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_rv_plic_autogen_unittest.cc deleted file mode 100644 index 6c94ba5b3caaa..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rv_plic_autogen_unittest.cc +++ /dev/null @@ -1,59 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_rv_plic_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "rv_plic_regs.h" // Generated. - -namespace dif_rv_plic_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class RvPlicTest : public Test, public MmioTest { - protected: - dif_rv_plic_t rv_plic_ = {.base_addr = dev().region()}; -}; - -class InitTest : public RvPlicTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_rv_plic_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_rv_plic_init(dev().region(), &rv_plic_)); -} - -class AlertForceTest : public RvPlicTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_rv_plic_alert_force(nullptr, kDifRvPlicAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_rv_plic_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(RV_PLIC_ALERT_TEST_REG_OFFSET, - {{RV_PLIC_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_rv_plic_alert_force(&rv_plic_, kDifRvPlicAlertFatalFault)); -} - -} // namespace -} // namespace dif_rv_plic_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_rv_timer_autogen.c b/sw/device/lib/dif/autogen/dif_rv_timer_autogen.c deleted file mode 100644 index 4dfe11149b71f..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rv_timer_autogen.c +++ /dev/null @@ -1,382 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_rv_timer_autogen.h" - -#include -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "rv_timer_regs.h" // Generated. - -static_assert(RV_TIMER_INTR_STATE0_IS_0_BIT == RV_TIMER_INTR_ENABLE0_IE_0_BIT, - "Expected IRQ bit offsets to match across STATE/ENABLE regs."); -static_assert(RV_TIMER_INTR_STATE0_IS_0_BIT == RV_TIMER_INTR_TEST0_T_0_BIT, - "Expected IRQ bit offsets to match across STATE/ENABLE regs."); - -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_init(mmio_region_t base_addr, - dif_rv_timer_t *rv_timer) { - if (rv_timer == NULL) { - return kDifBadArg; - } - - rv_timer->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_rv_timer_alert_force(const dif_rv_timer_t *rv_timer, - dif_rv_timer_alert_t alert) { - if (rv_timer == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifRvTimerAlertFatalFault: - alert_idx = RV_TIMER_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(rv_timer->base_addr, - (ptrdiff_t)RV_TIMER_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -typedef enum dif_rv_timer_intr_reg { - kDifRvTimerIntrRegState = 0, - kDifRvTimerIntrRegEnable = 1, - kDifRvTimerIntrRegTest = 2, -} dif_rv_timer_intr_reg_t; - -static bool rv_timer_get_irq_reg_offset(dif_rv_timer_intr_reg_t intr_reg, - dif_rv_timer_irq_t irq, - uint32_t *intr_reg_offset) { - switch (intr_reg) { - case kDifRvTimerIntrRegState: - switch (irq) { - case kDifRvTimerIrqTimerExpiredHart0Timer0: - *intr_reg_offset = RV_TIMER_INTR_STATE0_REG_OFFSET; - break; - default: - return false; - } - break; - case kDifRvTimerIntrRegEnable: - switch (irq) { - case kDifRvTimerIrqTimerExpiredHart0Timer0: - *intr_reg_offset = RV_TIMER_INTR_ENABLE0_REG_OFFSET; - break; - default: - return false; - } - break; - case kDifRvTimerIntrRegTest: - switch (irq) { - case kDifRvTimerIrqTimerExpiredHart0Timer0: - *intr_reg_offset = RV_TIMER_INTR_TEST0_REG_OFFSET; - break; - default: - return false; - } - break; - default: - return false; - } - - return true; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool rv_timer_get_irq_bit_index(dif_rv_timer_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifRvTimerIrqTimerExpiredHart0Timer0: - *index_out = RV_TIMER_INTR_STATE0_IS_0_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_get_type(const dif_rv_timer_t *rv_timer, - dif_rv_timer_irq_t irq, - dif_irq_type_t *type) { - if (rv_timer == NULL || type == NULL || irq < 0 || - irq > kDifRvTimerIrqTimerExpiredHart0Timer0) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_get_state( - const dif_rv_timer_t *rv_timer, uint32_t hart_id, - dif_rv_timer_irq_state_snapshot_t *snapshot) { - if (rv_timer == NULL || snapshot == NULL) { - return kDifBadArg; - } - - switch (hart_id) { - case 0: - *snapshot = mmio_region_read32( - rv_timer->base_addr, (ptrdiff_t)RV_TIMER_INTR_STATE0_REG_OFFSET); - - break; - default: - return kDifBadArg; - } - - return kDifOk; -} - -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, - (ptrdiff_t)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) { - if (rv_timer == NULL || is_pending == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!rv_timer_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t reg_offset = 0; - if (!rv_timer_get_irq_reg_offset(kDifRvTimerIntrRegState, irq, ®_offset)) { - return kDifBadArg; - } - uint32_t intr_state_reg = - mmio_region_read32(rv_timer->base_addr, (ptrdiff_t)reg_offset); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_acknowledge_all(const dif_rv_timer_t *rv_timer, - uint32_t hart_id) { - if (rv_timer == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - switch (hart_id) { - case 0: - mmio_region_write32(rv_timer->base_addr, - (ptrdiff_t)RV_TIMER_INTR_STATE0_REG_OFFSET, - UINT32_MAX); - - break; - default: - return kDifBadArg; - } - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_acknowledge(const dif_rv_timer_t *rv_timer, - dif_rv_timer_irq_t irq) { - if (rv_timer == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!rv_timer_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - uint32_t reg_offset = 0; - if (!rv_timer_get_irq_reg_offset(kDifRvTimerIntrRegState, irq, ®_offset)) { - return kDifBadArg; - } - mmio_region_write32(rv_timer->base_addr, (ptrdiff_t)reg_offset, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_force(const dif_rv_timer_t *rv_timer, - dif_rv_timer_irq_t irq, const bool val) { - if (rv_timer == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!rv_timer_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - uint32_t reg_offset = 0; - if (!rv_timer_get_irq_reg_offset(kDifRvTimerIntrRegTest, irq, ®_offset)) { - return kDifBadArg; - } - mmio_region_write32(rv_timer->base_addr, (ptrdiff_t)reg_offset, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_get_enabled(const dif_rv_timer_t *rv_timer, - dif_rv_timer_irq_t irq, - dif_toggle_t *state) { - if (rv_timer == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!rv_timer_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t reg_offset = 0; - if (!rv_timer_get_irq_reg_offset(kDifRvTimerIntrRegEnable, irq, - ®_offset)) { - return kDifBadArg; - } - uint32_t intr_enable_reg = - mmio_region_read32(rv_timer->base_addr, (ptrdiff_t)reg_offset); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_set_enabled(const dif_rv_timer_t *rv_timer, - dif_rv_timer_irq_t irq, - dif_toggle_t state) { - if (rv_timer == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!rv_timer_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t reg_offset = 0; - if (!rv_timer_get_irq_reg_offset(kDifRvTimerIntrRegEnable, irq, - ®_offset)) { - return kDifBadArg; - } - uint32_t intr_enable_reg = - mmio_region_read32(rv_timer->base_addr, (ptrdiff_t)reg_offset); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(rv_timer->base_addr, (ptrdiff_t)reg_offset, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_disable_all( - const dif_rv_timer_t *rv_timer, uint32_t hart_id, - dif_rv_timer_irq_enable_snapshot_t *snapshot) { - if (rv_timer == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - switch (hart_id) { - case 0: - *snapshot = mmio_region_read32( - rv_timer->base_addr, (ptrdiff_t)RV_TIMER_INTR_ENABLE0_REG_OFFSET); - - break; - default: - return kDifBadArg; - } - } - - // Disable all interrupts. - switch (hart_id) { - case 0: - mmio_region_write32(rv_timer->base_addr, - (ptrdiff_t)RV_TIMER_INTR_ENABLE0_REG_OFFSET, 0u); - - break; - default: - return kDifBadArg; - } - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_restore_all( - const dif_rv_timer_t *rv_timer, uint32_t hart_id, - const dif_rv_timer_irq_enable_snapshot_t *snapshot) { - if (rv_timer == NULL || snapshot == NULL) { - return kDifBadArg; - } - - switch (hart_id) { - case 0: - mmio_region_write32(rv_timer->base_addr, - (ptrdiff_t)RV_TIMER_INTR_ENABLE0_REG_OFFSET, - *snapshot); - - break; - default: - return kDifBadArg; - } - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_rv_timer_autogen.h b/sw/device/lib/dif/autogen/dif_rv_timer_autogen.h deleted file mode 100644 index c2eab9293474e..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rv_timer_autogen.h +++ /dev/null @@ -1,249 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_RV_TIMER_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_RV_TIMER_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief RV_TIMER Device Interface - * Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to rv_timer. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_rv_timer { - /** - * The base address for the rv_timer hardware registers. - */ - mmio_region_t base_addr; -} dif_rv_timer_t; - -/** - * Creates a new handle for a(n) rv_timer peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the rv_timer peripheral. - * @param[out] rv_timer Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_init(mmio_region_t base_addr, - dif_rv_timer_t *rv_timer); - -/** - * A rv_timer alert type. - */ -typedef enum dif_rv_timer_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected inside the RV_TIMER unit. - */ - kDifRvTimerAlertFatalFault = 0, -} dif_rv_timer_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param rv_timer A rv_timer handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_alert_force(const dif_rv_timer_t *rv_timer, - dif_rv_timer_alert_t alert); - -/** - * A rv_timer interrupt request type. - */ -typedef enum dif_rv_timer_irq { - /** - * Raised if hart0's timer0 expired (mtimecmp >= mtime) - */ - kDifRvTimerIrqTimerExpiredHart0Timer0 = 0, -} dif_rv_timer_irq_t; - -/** - * 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()` - * and `dif_rv_timer_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_rv_timer_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param rv_timer A rv_timer handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_get_type(const dif_rv_timer_t *rv_timer, - dif_rv_timer_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param rv_timer A rv_timer handle. - * @param hart_id The hart to manipulate. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_get_state( - const dif_rv_timer_t *rv_timer, uint32_t hart_id, - dif_rv_timer_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param rv_timer A rv_timer handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param rv_timer A rv_timer handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_acknowledge_all(const dif_rv_timer_t *rv_timer, - uint32_t hart_id); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param rv_timer A rv_timer handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_acknowledge(const dif_rv_timer_t *rv_timer, - dif_rv_timer_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param rv_timer A rv_timer handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_force(const dif_rv_timer_t *rv_timer, - dif_rv_timer_irq_t irq, const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_rv_timer_irq_disable_all()` and `dif_rv_timer_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_rv_timer_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param rv_timer A rv_timer handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_get_enabled(const dif_rv_timer_t *rv_timer, - dif_rv_timer_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param rv_timer A rv_timer handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_set_enabled(const dif_rv_timer_t *rv_timer, - dif_rv_timer_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param rv_timer A rv_timer handle. - * @param hart_id The hart to manipulate. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_disable_all( - const dif_rv_timer_t *rv_timer, uint32_t hart_id, - dif_rv_timer_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param rv_timer A rv_timer handle. - * @param hart_id The hart to manipulate. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_rv_timer_irq_restore_all( - const dif_rv_timer_t *rv_timer, uint32_t hart_id, - const dif_rv_timer_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_RV_TIMER_AUTOGEN_H_ 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 deleted file mode 100644 index d33a51fed58cb..0000000000000 --- a/sw/device/lib/dif/autogen/dif_rv_timer_autogen_unittest.cc +++ /dev/null @@ -1,362 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_rv_timer_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "rv_timer_regs.h" // Generated. - -namespace dif_rv_timer_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class RvTimerTest : public Test, public MmioTest { - protected: - dif_rv_timer_t rv_timer_ = {.base_addr = dev().region()}; -}; - -class InitTest : public RvTimerTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_rv_timer_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_rv_timer_init(dev().region(), &rv_timer_)); -} - -class AlertForceTest : public RvTimerTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_rv_timer_alert_force(nullptr, kDifRvTimerAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_rv_timer_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(RV_TIMER_ALERT_TEST_REG_OFFSET, - {{RV_TIMER_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK( - dif_rv_timer_alert_force(&rv_timer_, kDifRvTimerAlertFatalFault)); -} - -class IrqGetTypeTest : public RvTimerTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_rv_timer_irq_get_type( - nullptr, kDifRvTimerIrqTimerExpiredHart0Timer0, &type)); - - EXPECT_DIF_BADARG(dif_rv_timer_irq_get_type( - &rv_timer_, kDifRvTimerIrqTimerExpiredHart0Timer0, nullptr)); - - EXPECT_DIF_BADARG(dif_rv_timer_irq_get_type( - nullptr, kDifRvTimerIrqTimerExpiredHart0Timer0, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_rv_timer_irq_get_type( - &rv_timer_, - static_cast(kDifRvTimerIrqTimerExpiredHart0Timer0 + - 1), - &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_rv_timer_irq_get_type( - &rv_timer_, kDifRvTimerIrqTimerExpiredHart0Timer0, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public RvTimerTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_rv_timer_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_rv_timer_irq_get_state(nullptr, 0, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_rv_timer_irq_get_state(&rv_timer_, 0, nullptr)); - - EXPECT_DIF_BADARG(dif_rv_timer_irq_get_state(nullptr, 0, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_rv_timer_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(RV_TIMER_INTR_STATE0_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_rv_timer_irq_get_state(&rv_timer_, 0, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public RvTimerTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG(dif_rv_timer_irq_is_pending( - nullptr, kDifRvTimerIrqTimerExpiredHart0Timer0, &is_pending)); - - EXPECT_DIF_BADARG(dif_rv_timer_irq_is_pending( - &rv_timer_, kDifRvTimerIrqTimerExpiredHart0Timer0, nullptr)); - - EXPECT_DIF_BADARG(dif_rv_timer_irq_is_pending( - nullptr, kDifRvTimerIrqTimerExpiredHart0Timer0, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_rv_timer_irq_is_pending( - &rv_timer_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(RV_TIMER_INTR_STATE0_REG_OFFSET, {{0, true}}); - EXPECT_DIF_OK(dif_rv_timer_irq_is_pending( - &rv_timer_, kDifRvTimerIrqTimerExpiredHart0Timer0, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 1; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_rv_timer_irq_acknowledge_all(nullptr, 0)); -} - -TEST_F(AcknowledgeAllTest, BadHartId) { - EXPECT_DIF_BADARG(dif_rv_timer_irq_acknowledge_all(nullptr, 1)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(RV_TIMER_INTR_STATE0_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_rv_timer_irq_acknowledge_all(&rv_timer_, 0)); -} - -class IrqAcknowledgeTest : public RvTimerTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG(dif_rv_timer_irq_acknowledge( - nullptr, kDifRvTimerIrqTimerExpiredHart0Timer0)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG(dif_rv_timer_irq_acknowledge( - nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(RV_TIMER_INTR_STATE0_REG_OFFSET, {{0, true}}); - EXPECT_DIF_OK(dif_rv_timer_irq_acknowledge( - &rv_timer_, kDifRvTimerIrqTimerExpiredHart0Timer0)); -} - -class IrqForceTest : public RvTimerTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_rv_timer_irq_force( - nullptr, kDifRvTimerIrqTimerExpiredHart0Timer0, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG(dif_rv_timer_irq_force( - nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(RV_TIMER_INTR_TEST0_REG_OFFSET, {{0, true}}); - EXPECT_DIF_OK(dif_rv_timer_irq_force( - &rv_timer_, kDifRvTimerIrqTimerExpiredHart0Timer0, true)); -} - -class IrqGetEnabledTest : public RvTimerTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_rv_timer_irq_get_enabled( - nullptr, kDifRvTimerIrqTimerExpiredHart0Timer0, &irq_state)); - - EXPECT_DIF_BADARG(dif_rv_timer_irq_get_enabled( - &rv_timer_, kDifRvTimerIrqTimerExpiredHart0Timer0, nullptr)); - - EXPECT_DIF_BADARG(dif_rv_timer_irq_get_enabled( - nullptr, kDifRvTimerIrqTimerExpiredHart0Timer0, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_rv_timer_irq_get_enabled( - &rv_timer_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(RV_TIMER_INTR_ENABLE0_REG_OFFSET, {{0, true}}); - EXPECT_DIF_OK(dif_rv_timer_irq_get_enabled( - &rv_timer_, kDifRvTimerIrqTimerExpiredHart0Timer0, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); -} - -class IrqSetEnabledTest : public RvTimerTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_rv_timer_irq_set_enabled( - nullptr, kDifRvTimerIrqTimerExpiredHart0Timer0, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_rv_timer_irq_set_enabled( - &rv_timer_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(RV_TIMER_INTR_ENABLE0_REG_OFFSET, {{0, 0x1, true}}); - EXPECT_DIF_OK(dif_rv_timer_irq_set_enabled( - &rv_timer_, kDifRvTimerIrqTimerExpiredHart0Timer0, irq_state)); -} - -class IrqDisableAllTest : public RvTimerTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_rv_timer_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_rv_timer_irq_disable_all(nullptr, 0, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_rv_timer_irq_disable_all(nullptr, 0, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(RV_TIMER_INTR_ENABLE0_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_rv_timer_irq_disable_all(&rv_timer_, 0, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_rv_timer_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(RV_TIMER_INTR_ENABLE0_REG_OFFSET, 0); - EXPECT_WRITE32(RV_TIMER_INTR_ENABLE0_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_rv_timer_irq_disable_all(&rv_timer_, 0, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_rv_timer_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(RV_TIMER_INTR_ENABLE0_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(RV_TIMER_INTR_ENABLE0_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_rv_timer_irq_disable_all(&rv_timer_, 0, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public RvTimerTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_rv_timer_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_rv_timer_irq_restore_all(nullptr, 0, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_rv_timer_irq_restore_all(&rv_timer_, 0, nullptr)); - - EXPECT_DIF_BADARG(dif_rv_timer_irq_restore_all(nullptr, 0, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_rv_timer_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(RV_TIMER_INTR_ENABLE0_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_rv_timer_irq_restore_all(&rv_timer_, 0, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_rv_timer_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(RV_TIMER_INTR_ENABLE0_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_rv_timer_irq_restore_all(&rv_timer_, 0, &irq_snapshot)); -} - -} // namespace -} // namespace dif_rv_timer_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen.c b/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen.c deleted file mode 100644 index c7e60e6cc0602..0000000000000 --- a/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen.c +++ /dev/null @@ -1,277 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "sensor_ctrl_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_init(mmio_region_t base_addr, - dif_sensor_ctrl_t *sensor_ctrl) { - if (sensor_ctrl == NULL) { - return kDifBadArg; - } - - sensor_ctrl->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_sensor_ctrl_alert_force(const dif_sensor_ctrl_t *sensor_ctrl, - dif_sensor_ctrl_alert_t alert) { - if (sensor_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifSensorCtrlAlertRecovAlert: - alert_idx = SENSOR_CTRL_ALERT_TEST_RECOV_ALERT_BIT; - break; - case kDifSensorCtrlAlertFatalAlert: - alert_idx = SENSOR_CTRL_ALERT_TEST_FATAL_ALERT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(sensor_ctrl->base_addr, - (ptrdiff_t)SENSOR_CTRL_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool sensor_ctrl_get_irq_bit_index(dif_sensor_ctrl_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifSensorCtrlIrqIoStatusChange: - *index_out = SENSOR_CTRL_INTR_COMMON_IO_STATUS_CHANGE_BIT; - break; - case kDifSensorCtrlIrqInitStatusChange: - *index_out = SENSOR_CTRL_INTR_COMMON_INIT_STATUS_CHANGE_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, - kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_get_type(const dif_sensor_ctrl_t *sensor_ctrl, - dif_sensor_ctrl_irq_t irq, - dif_irq_type_t *type) { - if (sensor_ctrl == NULL || type == NULL || irq < 0 || - irq > kDifSensorCtrlIrqInitStatusChange) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_get_state( - const dif_sensor_ctrl_t *sensor_ctrl, - dif_sensor_ctrl_irq_state_snapshot_t *snapshot) { - if (sensor_ctrl == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(sensor_ctrl->base_addr, - (ptrdiff_t)SENSOR_CTRL_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, - (ptrdiff_t)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) { - if (sensor_ctrl == NULL || is_pending == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!sensor_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - sensor_ctrl->base_addr, (ptrdiff_t)SENSOR_CTRL_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_acknowledge_all( - const dif_sensor_ctrl_t *sensor_ctrl) { - if (sensor_ctrl == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(sensor_ctrl->base_addr, - (ptrdiff_t)SENSOR_CTRL_INTR_STATE_REG_OFFSET, UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_acknowledge( - const dif_sensor_ctrl_t *sensor_ctrl, dif_sensor_ctrl_irq_t irq) { - if (sensor_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!sensor_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(sensor_ctrl->base_addr, - (ptrdiff_t)SENSOR_CTRL_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_force(const dif_sensor_ctrl_t *sensor_ctrl, - dif_sensor_ctrl_irq_t irq, - const bool val) { - if (sensor_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!sensor_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(sensor_ctrl->base_addr, - (ptrdiff_t)SENSOR_CTRL_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_get_enabled( - const dif_sensor_ctrl_t *sensor_ctrl, dif_sensor_ctrl_irq_t irq, - dif_toggle_t *state) { - if (sensor_ctrl == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!sensor_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - sensor_ctrl->base_addr, (ptrdiff_t)SENSOR_CTRL_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_set_enabled( - const dif_sensor_ctrl_t *sensor_ctrl, dif_sensor_ctrl_irq_t irq, - dif_toggle_t state) { - if (sensor_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!sensor_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - sensor_ctrl->base_addr, (ptrdiff_t)SENSOR_CTRL_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(sensor_ctrl->base_addr, - (ptrdiff_t)SENSOR_CTRL_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_disable_all( - const dif_sensor_ctrl_t *sensor_ctrl, - dif_sensor_ctrl_irq_enable_snapshot_t *snapshot) { - if (sensor_ctrl == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32( - sensor_ctrl->base_addr, (ptrdiff_t)SENSOR_CTRL_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(sensor_ctrl->base_addr, - (ptrdiff_t)SENSOR_CTRL_INTR_ENABLE_REG_OFFSET, 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_restore_all( - const dif_sensor_ctrl_t *sensor_ctrl, - const dif_sensor_ctrl_irq_enable_snapshot_t *snapshot) { - if (sensor_ctrl == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(sensor_ctrl->base_addr, - (ptrdiff_t)SENSOR_CTRL_INTR_ENABLE_REG_OFFSET, *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen.h b/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen.h deleted file mode 100644 index a1cfa92c34883..0000000000000 --- a/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen.h +++ /dev/null @@ -1,253 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_SENSOR_CTRL_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_SENSOR_CTRL_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief SENSOR_CTRL Device Interface - * Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to sensor_ctrl. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_sensor_ctrl { - /** - * The base address for the sensor_ctrl hardware registers. - */ - mmio_region_t base_addr; -} dif_sensor_ctrl_t; - -/** - * Creates a new handle for a(n) sensor_ctrl peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the sensor_ctrl peripheral. - * @param[out] sensor_ctrl Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_init(mmio_region_t base_addr, - dif_sensor_ctrl_t *sensor_ctrl); - -/** - * A sensor_ctrl alert type. - */ -typedef enum dif_sensor_ctrl_alert { - /** - * Recoverable sensor_ctrl alerts - */ - kDifSensorCtrlAlertRecovAlert = 0, - /** - * Fatal sensor_ctrl alerts - */ - kDifSensorCtrlAlertFatalAlert = 1, -} dif_sensor_ctrl_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param sensor_ctrl A sensor_ctrl handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_alert_force(const dif_sensor_ctrl_t *sensor_ctrl, - dif_sensor_ctrl_alert_t alert); - -/** - * A sensor_ctrl interrupt request type. - */ -typedef enum dif_sensor_ctrl_irq { - /** - * Io power status has changed - */ - kDifSensorCtrlIrqIoStatusChange = 0, - /** - * Ast init status has changed - */ - kDifSensorCtrlIrqInitStatusChange = 1, -} dif_sensor_ctrl_irq_t; - -/** - * 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()` - * and `dif_sensor_ctrl_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_sensor_ctrl_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param sensor_ctrl A sensor_ctrl handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_get_type(const dif_sensor_ctrl_t *sensor_ctrl, - dif_sensor_ctrl_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param sensor_ctrl A sensor_ctrl handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_get_state( - const dif_sensor_ctrl_t *sensor_ctrl, - dif_sensor_ctrl_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param sensor_ctrl A sensor_ctrl handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param sensor_ctrl A sensor_ctrl handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_acknowledge_all( - const dif_sensor_ctrl_t *sensor_ctrl); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param sensor_ctrl A sensor_ctrl handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_acknowledge( - const dif_sensor_ctrl_t *sensor_ctrl, dif_sensor_ctrl_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param sensor_ctrl A sensor_ctrl handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_force(const dif_sensor_ctrl_t *sensor_ctrl, - dif_sensor_ctrl_irq_t irq, - const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_sensor_ctrl_irq_disable_all()` and `dif_sensor_ctrl_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_sensor_ctrl_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param sensor_ctrl A sensor_ctrl handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_get_enabled( - const dif_sensor_ctrl_t *sensor_ctrl, dif_sensor_ctrl_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param sensor_ctrl A sensor_ctrl handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_set_enabled( - const dif_sensor_ctrl_t *sensor_ctrl, dif_sensor_ctrl_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param sensor_ctrl A sensor_ctrl handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_disable_all( - const dif_sensor_ctrl_t *sensor_ctrl, - dif_sensor_ctrl_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param sensor_ctrl A sensor_ctrl handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sensor_ctrl_irq_restore_all( - const dif_sensor_ctrl_t *sensor_ctrl, - const dif_sensor_ctrl_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_SENSOR_CTRL_AUTOGEN_H_ 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 deleted file mode 100644 index a7981ab956eb9..0000000000000 --- a/sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen_unittest.cc +++ /dev/null @@ -1,403 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_sensor_ctrl_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "sensor_ctrl_regs.h" // Generated. - -namespace dif_sensor_ctrl_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class SensorCtrlTest : public Test, public MmioTest { - protected: - dif_sensor_ctrl_t sensor_ctrl_ = {.base_addr = dev().region()}; -}; - -class InitTest : public SensorCtrlTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_sensor_ctrl_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_sensor_ctrl_init(dev().region(), &sensor_ctrl_)); -} - -class AlertForceTest : public SensorCtrlTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_sensor_ctrl_alert_force(nullptr, kDifSensorCtrlAlertRecovAlert)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG(dif_sensor_ctrl_alert_force( - nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(SENSOR_CTRL_ALERT_TEST_REG_OFFSET, - {{SENSOR_CTRL_ALERT_TEST_RECOV_ALERT_BIT, true}}); - EXPECT_DIF_OK(dif_sensor_ctrl_alert_force(&sensor_ctrl_, - kDifSensorCtrlAlertRecovAlert)); - - // Force last alert. - EXPECT_WRITE32(SENSOR_CTRL_ALERT_TEST_REG_OFFSET, - {{SENSOR_CTRL_ALERT_TEST_FATAL_ALERT_BIT, true}}); - EXPECT_DIF_OK(dif_sensor_ctrl_alert_force(&sensor_ctrl_, - kDifSensorCtrlAlertFatalAlert)); -} - -class IrqGetTypeTest : public SensorCtrlTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_get_type( - nullptr, kDifSensorCtrlIrqIoStatusChange, &type)); - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_get_type( - &sensor_ctrl_, kDifSensorCtrlIrqIoStatusChange, nullptr)); - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_get_type( - nullptr, kDifSensorCtrlIrqIoStatusChange, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_get_type( - &sensor_ctrl_, - static_cast(kDifSensorCtrlIrqInitStatusChange + 1), - &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_sensor_ctrl_irq_get_type( - &sensor_ctrl_, kDifSensorCtrlIrqIoStatusChange, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public SensorCtrlTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_sensor_ctrl_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_get_state(&sensor_ctrl_, nullptr)); - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_sensor_ctrl_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(SENSOR_CTRL_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_sensor_ctrl_irq_get_state(&sensor_ctrl_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public SensorCtrlTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_is_pending( - nullptr, kDifSensorCtrlIrqIoStatusChange, &is_pending)); - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_is_pending( - &sensor_ctrl_, kDifSensorCtrlIrqIoStatusChange, nullptr)); - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_is_pending( - nullptr, kDifSensorCtrlIrqIoStatusChange, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_is_pending( - &sensor_ctrl_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(SENSOR_CTRL_INTR_STATE_REG_OFFSET, - {{SENSOR_CTRL_INTR_STATE_IO_STATUS_CHANGE_BIT, true}}); - EXPECT_DIF_OK(dif_sensor_ctrl_irq_is_pending( - &sensor_ctrl_, kDifSensorCtrlIrqIoStatusChange, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(SENSOR_CTRL_INTR_STATE_REG_OFFSET, - {{SENSOR_CTRL_INTR_STATE_INIT_STATUS_CHANGE_BIT, false}}); - EXPECT_DIF_OK(dif_sensor_ctrl_irq_is_pending( - &sensor_ctrl_, kDifSensorCtrlIrqInitStatusChange, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 2; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(SENSOR_CTRL_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_sensor_ctrl_irq_acknowledge_all(&sensor_ctrl_)); -} - -class IrqAcknowledgeTest : public SensorCtrlTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_acknowledge( - nullptr, kDifSensorCtrlIrqIoStatusChange)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_acknowledge( - nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(SENSOR_CTRL_INTR_STATE_REG_OFFSET, - {{SENSOR_CTRL_INTR_STATE_IO_STATUS_CHANGE_BIT, true}}); - EXPECT_DIF_OK(dif_sensor_ctrl_irq_acknowledge( - &sensor_ctrl_, kDifSensorCtrlIrqIoStatusChange)); - - // Clear the last IRQ state. - EXPECT_WRITE32(SENSOR_CTRL_INTR_STATE_REG_OFFSET, - {{SENSOR_CTRL_INTR_STATE_INIT_STATUS_CHANGE_BIT, true}}); - EXPECT_DIF_OK(dif_sensor_ctrl_irq_acknowledge( - &sensor_ctrl_, kDifSensorCtrlIrqInitStatusChange)); -} - -class IrqForceTest : public SensorCtrlTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_force( - nullptr, kDifSensorCtrlIrqIoStatusChange, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_force( - nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(SENSOR_CTRL_INTR_TEST_REG_OFFSET, - {{SENSOR_CTRL_INTR_TEST_IO_STATUS_CHANGE_BIT, true}}); - EXPECT_DIF_OK(dif_sensor_ctrl_irq_force( - &sensor_ctrl_, kDifSensorCtrlIrqIoStatusChange, true)); - - // Force last IRQ. - EXPECT_WRITE32(SENSOR_CTRL_INTR_TEST_REG_OFFSET, - {{SENSOR_CTRL_INTR_TEST_INIT_STATUS_CHANGE_BIT, true}}); - EXPECT_DIF_OK(dif_sensor_ctrl_irq_force( - &sensor_ctrl_, kDifSensorCtrlIrqInitStatusChange, true)); -} - -class IrqGetEnabledTest : public SensorCtrlTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_get_enabled( - nullptr, kDifSensorCtrlIrqIoStatusChange, &irq_state)); - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_get_enabled( - &sensor_ctrl_, kDifSensorCtrlIrqIoStatusChange, nullptr)); - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_get_enabled( - nullptr, kDifSensorCtrlIrqIoStatusChange, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_get_enabled( - &sensor_ctrl_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(SENSOR_CTRL_INTR_ENABLE_REG_OFFSET, - {{SENSOR_CTRL_INTR_ENABLE_IO_STATUS_CHANGE_BIT, true}}); - EXPECT_DIF_OK(dif_sensor_ctrl_irq_get_enabled( - &sensor_ctrl_, kDifSensorCtrlIrqIoStatusChange, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(SENSOR_CTRL_INTR_ENABLE_REG_OFFSET, - {{SENSOR_CTRL_INTR_ENABLE_INIT_STATUS_CHANGE_BIT, false}}); - EXPECT_DIF_OK(dif_sensor_ctrl_irq_get_enabled( - &sensor_ctrl_, kDifSensorCtrlIrqInitStatusChange, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public SensorCtrlTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_set_enabled( - nullptr, kDifSensorCtrlIrqIoStatusChange, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_set_enabled( - &sensor_ctrl_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(SENSOR_CTRL_INTR_ENABLE_REG_OFFSET, - {{SENSOR_CTRL_INTR_ENABLE_IO_STATUS_CHANGE_BIT, 0x1, true}}); - EXPECT_DIF_OK(dif_sensor_ctrl_irq_set_enabled( - &sensor_ctrl_, kDifSensorCtrlIrqIoStatusChange, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(SENSOR_CTRL_INTR_ENABLE_REG_OFFSET, - {{SENSOR_CTRL_INTR_ENABLE_INIT_STATUS_CHANGE_BIT, 0x1, false}}); - EXPECT_DIF_OK(dif_sensor_ctrl_irq_set_enabled( - &sensor_ctrl_, kDifSensorCtrlIrqInitStatusChange, irq_state)); -} - -class IrqDisableAllTest : public SensorCtrlTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_sensor_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(SENSOR_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_sensor_ctrl_irq_disable_all(&sensor_ctrl_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_sensor_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(SENSOR_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(SENSOR_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_sensor_ctrl_irq_disable_all(&sensor_ctrl_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_sensor_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(SENSOR_CTRL_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(SENSOR_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_sensor_ctrl_irq_disable_all(&sensor_ctrl_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public SensorCtrlTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_sensor_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_restore_all(&sensor_ctrl_, nullptr)); - - EXPECT_DIF_BADARG(dif_sensor_ctrl_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_sensor_ctrl_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(SENSOR_CTRL_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_sensor_ctrl_irq_restore_all(&sensor_ctrl_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_sensor_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(SENSOR_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_sensor_ctrl_irq_restore_all(&sensor_ctrl_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_sensor_ctrl_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_spi_device_autogen.c b/sw/device/lib/dif/autogen/dif_spi_device_autogen.c deleted file mode 100644 index dcbf0f7e61aac..0000000000000 --- a/sw/device/lib/dif/autogen/dif_spi_device_autogen.c +++ /dev/null @@ -1,292 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_spi_device_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "spi_device_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_init(mmio_region_t base_addr, - dif_spi_device_t *spi_device) { - if (spi_device == NULL) { - return kDifBadArg; - } - - spi_device->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_spi_device_alert_force(const dif_spi_device_t *spi_device, - dif_spi_device_alert_t alert) { - if (spi_device == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifSpiDeviceAlertFatalFault: - alert_idx = SPI_DEVICE_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(spi_device->base_addr, - (ptrdiff_t)SPI_DEVICE_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool spi_device_get_irq_bit_index(dif_spi_device_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifSpiDeviceIrqUploadCmdfifoNotEmpty: - *index_out = SPI_DEVICE_INTR_COMMON_UPLOAD_CMDFIFO_NOT_EMPTY_BIT; - break; - case kDifSpiDeviceIrqUploadPayloadNotEmpty: - *index_out = SPI_DEVICE_INTR_COMMON_UPLOAD_PAYLOAD_NOT_EMPTY_BIT; - break; - case kDifSpiDeviceIrqUploadPayloadOverflow: - *index_out = SPI_DEVICE_INTR_COMMON_UPLOAD_PAYLOAD_OVERFLOW_BIT; - break; - case kDifSpiDeviceIrqReadbufWatermark: - *index_out = SPI_DEVICE_INTR_COMMON_READBUF_WATERMARK_BIT; - break; - case kDifSpiDeviceIrqReadbufFlip: - *index_out = SPI_DEVICE_INTR_COMMON_READBUF_FLIP_BIT; - break; - case kDifSpiDeviceIrqTpmHeaderNotEmpty: - *index_out = SPI_DEVICE_INTR_COMMON_TPM_HEADER_NOT_EMPTY_BIT; - break; - case kDifSpiDeviceIrqTpmRdfifoCmdEnd: - *index_out = SPI_DEVICE_INTR_COMMON_TPM_RDFIFO_CMD_END_BIT; - break; - case kDifSpiDeviceIrqTpmRdfifoDrop: - *index_out = SPI_DEVICE_INTR_COMMON_TPM_RDFIFO_DROP_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, - kDifIrqTypeEvent, kDifIrqTypeStatus, kDifIrqTypeEvent, kDifIrqTypeEvent, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_get_type(const dif_spi_device_t *spi_device, - dif_spi_device_irq_t irq, - dif_irq_type_t *type) { - if (spi_device == NULL || type == NULL || irq < 0 || - irq > kDifSpiDeviceIrqTpmRdfifoDrop) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_get_state( - const dif_spi_device_t *spi_device, - dif_spi_device_irq_state_snapshot_t *snapshot) { - if (spi_device == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(spi_device->base_addr, - (ptrdiff_t)SPI_DEVICE_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, - (ptrdiff_t)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) { - if (spi_device == NULL || is_pending == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!spi_device_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - spi_device->base_addr, (ptrdiff_t)SPI_DEVICE_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_acknowledge_all( - const dif_spi_device_t *spi_device) { - if (spi_device == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(spi_device->base_addr, - (ptrdiff_t)SPI_DEVICE_INTR_STATE_REG_OFFSET, UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_acknowledge(const dif_spi_device_t *spi_device, - dif_spi_device_irq_t irq) { - if (spi_device == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!spi_device_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(spi_device->base_addr, - (ptrdiff_t)SPI_DEVICE_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_force(const dif_spi_device_t *spi_device, - dif_spi_device_irq_t irq, - const bool val) { - if (spi_device == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!spi_device_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(spi_device->base_addr, - (ptrdiff_t)SPI_DEVICE_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_get_enabled(const dif_spi_device_t *spi_device, - dif_spi_device_irq_t irq, - dif_toggle_t *state) { - if (spi_device == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!spi_device_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - spi_device->base_addr, (ptrdiff_t)SPI_DEVICE_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_set_enabled(const dif_spi_device_t *spi_device, - dif_spi_device_irq_t irq, - dif_toggle_t state) { - if (spi_device == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!spi_device_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - spi_device->base_addr, (ptrdiff_t)SPI_DEVICE_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(spi_device->base_addr, - (ptrdiff_t)SPI_DEVICE_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_disable_all( - const dif_spi_device_t *spi_device, - dif_spi_device_irq_enable_snapshot_t *snapshot) { - if (spi_device == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32( - spi_device->base_addr, (ptrdiff_t)SPI_DEVICE_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(spi_device->base_addr, - (ptrdiff_t)SPI_DEVICE_INTR_ENABLE_REG_OFFSET, 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_restore_all( - const dif_spi_device_t *spi_device, - const dif_spi_device_irq_enable_snapshot_t *snapshot) { - if (spi_device == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(spi_device->base_addr, - (ptrdiff_t)SPI_DEVICE_INTR_ENABLE_REG_OFFSET, *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_spi_device_autogen.h b/sw/device/lib/dif/autogen/dif_spi_device_autogen.h deleted file mode 100644 index 4fdbf555a6201..0000000000000 --- a/sw/device/lib/dif/autogen/dif_spi_device_autogen.h +++ /dev/null @@ -1,281 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_SPI_DEVICE_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_SPI_DEVICE_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief SPI_DEVICE Device Interface - * Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to spi_device. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_spi_device { - /** - * The base address for the spi_device hardware registers. - */ - mmio_region_t base_addr; -} dif_spi_device_t; - -/** - * Creates a new handle for a(n) spi_device peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the spi_device peripheral. - * @param[out] spi_device Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_init(mmio_region_t base_addr, - dif_spi_device_t *spi_device); - -/** - * A spi_device alert type. - */ -typedef enum dif_spi_device_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifSpiDeviceAlertFatalFault = 0, -} dif_spi_device_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param spi_device A spi_device handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_alert_force(const dif_spi_device_t *spi_device, - dif_spi_device_alert_t alert); - -/** - * A spi_device interrupt request type. - */ -typedef enum dif_spi_device_irq { - /** - * Upload Command FIFO is not empty - */ - kDifSpiDeviceIrqUploadCmdfifoNotEmpty = 0, - /** - * Upload payload is not empty. The event occurs after SPI transaction - * completed - */ - kDifSpiDeviceIrqUploadPayloadNotEmpty = 1, - /** - * Upload payload overflow event. When a SPI Host system issues a command - * with payload more than 256B, this event is reported. When it happens, SW - * should read the last written payload index CSR to figure out the starting - * address of the last 256B. - */ - kDifSpiDeviceIrqUploadPayloadOverflow = 2, - /** - * Read Buffer Threshold event. The host system accesses greater than or - * equal to the threshold of a buffer. - */ - kDifSpiDeviceIrqReadbufWatermark = 3, - /** - * Read buffer flipped event. The host system accesses other side of buffer. - */ - kDifSpiDeviceIrqReadbufFlip = 4, - /** - * TPM Header(Command/Address) buffer available - */ - kDifSpiDeviceIrqTpmHeaderNotEmpty = 5, - /** - * TPM RdFIFO command ended. The TPM Read command targeting the RdFIFO ended. - * Check TPM_STATUS.rdfifo_aborted to see if the transaction completed. - */ - kDifSpiDeviceIrqTpmRdfifoCmdEnd = 6, - /** - * TPM RdFIFO data dropped. Data was dropped from the RdFIFO. Data was - * written while a read command was not active, and it was not accepted. This - * can occur when the host aborts a read command. - */ - kDifSpiDeviceIrqTpmRdfifoDrop = 7, -} dif_spi_device_irq_t; - -/** - * 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()` - * and `dif_spi_device_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_spi_device_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param spi_device A spi_device handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_get_type(const dif_spi_device_t *spi_device, - dif_spi_device_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param spi_device A spi_device handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_get_state( - const dif_spi_device_t *spi_device, - dif_spi_device_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param spi_device A spi_device handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param spi_device A spi_device handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_acknowledge_all( - const dif_spi_device_t *spi_device); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param spi_device A spi_device handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_acknowledge(const dif_spi_device_t *spi_device, - dif_spi_device_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param spi_device A spi_device handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_force(const dif_spi_device_t *spi_device, - dif_spi_device_irq_t irq, const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_spi_device_irq_disable_all()` and `dif_spi_device_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_spi_device_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param spi_device A spi_device handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_get_enabled(const dif_spi_device_t *spi_device, - dif_spi_device_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param spi_device A spi_device handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_set_enabled(const dif_spi_device_t *spi_device, - dif_spi_device_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param spi_device A spi_device handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_disable_all( - const dif_spi_device_t *spi_device, - dif_spi_device_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param spi_device A spi_device handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_device_irq_restore_all( - const dif_spi_device_t *spi_device, - const dif_spi_device_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_SPI_DEVICE_AUTOGEN_H_ 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 deleted file mode 100644 index 12ef04147477e..0000000000000 --- a/sw/device/lib/dif/autogen/dif_spi_device_autogen_unittest.cc +++ /dev/null @@ -1,398 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_spi_device_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "spi_device_regs.h" // Generated. - -namespace dif_spi_device_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class SpiDeviceTest : public Test, public MmioTest { - protected: - dif_spi_device_t spi_device_ = {.base_addr = dev().region()}; -}; - -class InitTest : public SpiDeviceTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_spi_device_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_spi_device_init(dev().region(), &spi_device_)); -} - -class AlertForceTest : public SpiDeviceTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_spi_device_alert_force(nullptr, kDifSpiDeviceAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG(dif_spi_device_alert_force( - nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(SPI_DEVICE_ALERT_TEST_REG_OFFSET, - {{SPI_DEVICE_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK( - dif_spi_device_alert_force(&spi_device_, kDifSpiDeviceAlertFatalFault)); -} - -class IrqGetTypeTest : public SpiDeviceTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_spi_device_irq_get_type( - nullptr, kDifSpiDeviceIrqUploadCmdfifoNotEmpty, &type)); - - EXPECT_DIF_BADARG(dif_spi_device_irq_get_type( - &spi_device_, kDifSpiDeviceIrqUploadCmdfifoNotEmpty, nullptr)); - - EXPECT_DIF_BADARG(dif_spi_device_irq_get_type( - nullptr, kDifSpiDeviceIrqUploadCmdfifoNotEmpty, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_spi_device_irq_get_type( - &spi_device_, - static_cast(kDifSpiDeviceIrqTpmRdfifoDrop + 1), - &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_spi_device_irq_get_type( - &spi_device_, kDifSpiDeviceIrqUploadCmdfifoNotEmpty, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public SpiDeviceTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_spi_device_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_spi_device_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_spi_device_irq_get_state(&spi_device_, nullptr)); - - EXPECT_DIF_BADARG(dif_spi_device_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_spi_device_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(SPI_DEVICE_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_spi_device_irq_get_state(&spi_device_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public SpiDeviceTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG(dif_spi_device_irq_is_pending( - nullptr, kDifSpiDeviceIrqUploadCmdfifoNotEmpty, &is_pending)); - - EXPECT_DIF_BADARG(dif_spi_device_irq_is_pending( - &spi_device_, kDifSpiDeviceIrqUploadCmdfifoNotEmpty, nullptr)); - - EXPECT_DIF_BADARG(dif_spi_device_irq_is_pending( - nullptr, kDifSpiDeviceIrqUploadCmdfifoNotEmpty, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_spi_device_irq_is_pending( - &spi_device_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(SPI_DEVICE_INTR_STATE_REG_OFFSET, - {{SPI_DEVICE_INTR_STATE_UPLOAD_CMDFIFO_NOT_EMPTY_BIT, true}}); - EXPECT_DIF_OK(dif_spi_device_irq_is_pending( - &spi_device_, kDifSpiDeviceIrqUploadCmdfifoNotEmpty, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(SPI_DEVICE_INTR_STATE_REG_OFFSET, - {{SPI_DEVICE_INTR_STATE_TPM_RDFIFO_DROP_BIT, false}}); - EXPECT_DIF_OK(dif_spi_device_irq_is_pending( - &spi_device_, kDifSpiDeviceIrqTpmRdfifoDrop, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 8; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_spi_device_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(SPI_DEVICE_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_spi_device_irq_acknowledge_all(&spi_device_)); -} - -class IrqAcknowledgeTest : public SpiDeviceTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG(dif_spi_device_irq_acknowledge( - nullptr, kDifSpiDeviceIrqUploadCmdfifoNotEmpty)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG(dif_spi_device_irq_acknowledge( - nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(SPI_DEVICE_INTR_STATE_REG_OFFSET, - {{SPI_DEVICE_INTR_STATE_UPLOAD_CMDFIFO_NOT_EMPTY_BIT, true}}); - EXPECT_DIF_OK(dif_spi_device_irq_acknowledge( - &spi_device_, kDifSpiDeviceIrqUploadCmdfifoNotEmpty)); - - // Clear the last IRQ state. - EXPECT_WRITE32(SPI_DEVICE_INTR_STATE_REG_OFFSET, - {{SPI_DEVICE_INTR_STATE_TPM_RDFIFO_DROP_BIT, true}}); - EXPECT_DIF_OK(dif_spi_device_irq_acknowledge(&spi_device_, - kDifSpiDeviceIrqTpmRdfifoDrop)); -} - -class IrqForceTest : public SpiDeviceTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_spi_device_irq_force( - nullptr, kDifSpiDeviceIrqUploadCmdfifoNotEmpty, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG(dif_spi_device_irq_force( - nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(SPI_DEVICE_INTR_TEST_REG_OFFSET, - {{SPI_DEVICE_INTR_TEST_UPLOAD_CMDFIFO_NOT_EMPTY_BIT, true}}); - EXPECT_DIF_OK(dif_spi_device_irq_force( - &spi_device_, kDifSpiDeviceIrqUploadCmdfifoNotEmpty, true)); - - // Force last IRQ. - EXPECT_WRITE32(SPI_DEVICE_INTR_TEST_REG_OFFSET, - {{SPI_DEVICE_INTR_TEST_TPM_RDFIFO_DROP_BIT, true}}); - EXPECT_DIF_OK(dif_spi_device_irq_force(&spi_device_, - kDifSpiDeviceIrqTpmRdfifoDrop, true)); -} - -class IrqGetEnabledTest : public SpiDeviceTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_spi_device_irq_get_enabled( - nullptr, kDifSpiDeviceIrqUploadCmdfifoNotEmpty, &irq_state)); - - EXPECT_DIF_BADARG(dif_spi_device_irq_get_enabled( - &spi_device_, kDifSpiDeviceIrqUploadCmdfifoNotEmpty, nullptr)); - - EXPECT_DIF_BADARG(dif_spi_device_irq_get_enabled( - nullptr, kDifSpiDeviceIrqUploadCmdfifoNotEmpty, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_spi_device_irq_get_enabled( - &spi_device_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(SPI_DEVICE_INTR_ENABLE_REG_OFFSET, - {{SPI_DEVICE_INTR_ENABLE_UPLOAD_CMDFIFO_NOT_EMPTY_BIT, true}}); - EXPECT_DIF_OK(dif_spi_device_irq_get_enabled( - &spi_device_, kDifSpiDeviceIrqUploadCmdfifoNotEmpty, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(SPI_DEVICE_INTR_ENABLE_REG_OFFSET, - {{SPI_DEVICE_INTR_ENABLE_TPM_RDFIFO_DROP_BIT, false}}); - EXPECT_DIF_OK(dif_spi_device_irq_get_enabled( - &spi_device_, kDifSpiDeviceIrqTpmRdfifoDrop, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public SpiDeviceTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_spi_device_irq_set_enabled( - nullptr, kDifSpiDeviceIrqUploadCmdfifoNotEmpty, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_spi_device_irq_set_enabled( - &spi_device_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32( - SPI_DEVICE_INTR_ENABLE_REG_OFFSET, - {{SPI_DEVICE_INTR_ENABLE_UPLOAD_CMDFIFO_NOT_EMPTY_BIT, 0x1, true}}); - EXPECT_DIF_OK(dif_spi_device_irq_set_enabled( - &spi_device_, kDifSpiDeviceIrqUploadCmdfifoNotEmpty, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(SPI_DEVICE_INTR_ENABLE_REG_OFFSET, - {{SPI_DEVICE_INTR_ENABLE_TPM_RDFIFO_DROP_BIT, 0x1, false}}); - EXPECT_DIF_OK(dif_spi_device_irq_set_enabled( - &spi_device_, kDifSpiDeviceIrqTpmRdfifoDrop, irq_state)); -} - -class IrqDisableAllTest : public SpiDeviceTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_spi_device_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_spi_device_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_spi_device_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(SPI_DEVICE_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_spi_device_irq_disable_all(&spi_device_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_spi_device_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(SPI_DEVICE_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(SPI_DEVICE_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_spi_device_irq_disable_all(&spi_device_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_spi_device_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(SPI_DEVICE_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(SPI_DEVICE_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_spi_device_irq_disable_all(&spi_device_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public SpiDeviceTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_spi_device_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_spi_device_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_spi_device_irq_restore_all(&spi_device_, nullptr)); - - EXPECT_DIF_BADARG(dif_spi_device_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_spi_device_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(SPI_DEVICE_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_spi_device_irq_restore_all(&spi_device_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_spi_device_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(SPI_DEVICE_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_spi_device_irq_restore_all(&spi_device_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_spi_device_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_spi_host_autogen.c b/sw/device/lib/dif/autogen/dif_spi_host_autogen.c deleted file mode 100644 index 6bf52a2471218..0000000000000 --- a/sw/device/lib/dif/autogen/dif_spi_host_autogen.c +++ /dev/null @@ -1,271 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_spi_host_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "spi_host_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_init(mmio_region_t base_addr, - dif_spi_host_t *spi_host) { - if (spi_host == NULL) { - return kDifBadArg; - } - - spi_host->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_spi_host_alert_force(const dif_spi_host_t *spi_host, - dif_spi_host_alert_t alert) { - if (spi_host == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifSpiHostAlertFatalFault: - alert_idx = SPI_HOST_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(spi_host->base_addr, - (ptrdiff_t)SPI_HOST_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool spi_host_get_irq_bit_index(dif_spi_host_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifSpiHostIrqError: - *index_out = SPI_HOST_INTR_COMMON_ERROR_BIT; - break; - case kDifSpiHostIrqSpiEvent: - *index_out = SPI_HOST_INTR_COMMON_SPI_EVENT_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeEvent, - kDifIrqTypeStatus, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_get_type(const dif_spi_host_t *spi_host, - dif_spi_host_irq_t irq, - dif_irq_type_t *type) { - if (spi_host == NULL || type == NULL || irq < 0 || - irq > kDifSpiHostIrqSpiEvent) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_get_state( - const dif_spi_host_t *spi_host, - dif_spi_host_irq_state_snapshot_t *snapshot) { - if (spi_host == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(spi_host->base_addr, - (ptrdiff_t)SPI_HOST_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, - (ptrdiff_t)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) { - if (spi_host == NULL || is_pending == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!spi_host_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - spi_host->base_addr, (ptrdiff_t)SPI_HOST_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_acknowledge_all(const dif_spi_host_t *spi_host) { - if (spi_host == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(spi_host->base_addr, - (ptrdiff_t)SPI_HOST_INTR_STATE_REG_OFFSET, UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_acknowledge(const dif_spi_host_t *spi_host, - dif_spi_host_irq_t irq) { - if (spi_host == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!spi_host_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(spi_host->base_addr, - (ptrdiff_t)SPI_HOST_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_force(const dif_spi_host_t *spi_host, - dif_spi_host_irq_t irq, const bool val) { - if (spi_host == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!spi_host_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(spi_host->base_addr, - (ptrdiff_t)SPI_HOST_INTR_TEST_REG_OFFSET, intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_get_enabled(const dif_spi_host_t *spi_host, - dif_spi_host_irq_t irq, - dif_toggle_t *state) { - if (spi_host == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!spi_host_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - spi_host->base_addr, (ptrdiff_t)SPI_HOST_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_set_enabled(const dif_spi_host_t *spi_host, - dif_spi_host_irq_t irq, - dif_toggle_t state) { - if (spi_host == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!spi_host_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - spi_host->base_addr, (ptrdiff_t)SPI_HOST_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(spi_host->base_addr, - (ptrdiff_t)SPI_HOST_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_disable_all( - const dif_spi_host_t *spi_host, - dif_spi_host_irq_enable_snapshot_t *snapshot) { - if (spi_host == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(spi_host->base_addr, - (ptrdiff_t)SPI_HOST_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(spi_host->base_addr, - (ptrdiff_t)SPI_HOST_INTR_ENABLE_REG_OFFSET, 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_restore_all( - const dif_spi_host_t *spi_host, - const dif_spi_host_irq_enable_snapshot_t *snapshot) { - if (spi_host == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(spi_host->base_addr, - (ptrdiff_t)SPI_HOST_INTR_ENABLE_REG_OFFSET, *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_spi_host_autogen.h b/sw/device/lib/dif/autogen/dif_spi_host_autogen.h deleted file mode 100644 index 2d2450bd087df..0000000000000 --- a/sw/device/lib/dif/autogen/dif_spi_host_autogen.h +++ /dev/null @@ -1,247 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_SPI_HOST_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_SPI_HOST_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief SPI_HOST Device Interface - * Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to spi_host. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_spi_host { - /** - * The base address for the spi_host hardware registers. - */ - mmio_region_t base_addr; -} dif_spi_host_t; - -/** - * Creates a new handle for a(n) spi_host peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the spi_host peripheral. - * @param[out] spi_host Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_init(mmio_region_t base_addr, - dif_spi_host_t *spi_host); - -/** - * A spi_host alert type. - */ -typedef enum dif_spi_host_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifSpiHostAlertFatalFault = 0, -} dif_spi_host_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param spi_host A spi_host handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_alert_force(const dif_spi_host_t *spi_host, - dif_spi_host_alert_t alert); - -/** - * A spi_host interrupt request type. - */ -typedef enum dif_spi_host_irq { - /** - * Error-related interrupts, see !!ERROR_ENABLE register for more information. - */ - kDifSpiHostIrqError = 0, - /** - * Event-related interrupts, see !!EVENT_ENABLE register for more information. - */ - kDifSpiHostIrqSpiEvent = 1, -} dif_spi_host_irq_t; - -/** - * 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()` - * and `dif_spi_host_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_spi_host_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param spi_host A spi_host handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_get_type(const dif_spi_host_t *spi_host, - dif_spi_host_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param spi_host A spi_host handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_get_state( - const dif_spi_host_t *spi_host, - dif_spi_host_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param spi_host A spi_host handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param spi_host A spi_host handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_acknowledge_all(const dif_spi_host_t *spi_host); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param spi_host A spi_host handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_acknowledge(const dif_spi_host_t *spi_host, - dif_spi_host_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param spi_host A spi_host handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_force(const dif_spi_host_t *spi_host, - dif_spi_host_irq_t irq, const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_spi_host_irq_disable_all()` and `dif_spi_host_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_spi_host_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param spi_host A spi_host handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_get_enabled(const dif_spi_host_t *spi_host, - dif_spi_host_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param spi_host A spi_host handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_set_enabled(const dif_spi_host_t *spi_host, - dif_spi_host_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param spi_host A spi_host handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_disable_all( - const dif_spi_host_t *spi_host, - dif_spi_host_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param spi_host A spi_host handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_spi_host_irq_restore_all( - const dif_spi_host_t *spi_host, - const dif_spi_host_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_SPI_HOST_AUTOGEN_H_ 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 deleted file mode 100644 index c606e5adeb5b9..0000000000000 --- a/sw/device/lib/dif/autogen/dif_spi_host_autogen_unittest.cc +++ /dev/null @@ -1,390 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_spi_host_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "spi_host_regs.h" // Generated. - -namespace dif_spi_host_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class SpiHostTest : public Test, public MmioTest { - protected: - dif_spi_host_t spi_host_ = {.base_addr = dev().region()}; -}; - -class InitTest : public SpiHostTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_spi_host_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_spi_host_init(dev().region(), &spi_host_)); -} - -class AlertForceTest : public SpiHostTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_spi_host_alert_force(nullptr, kDifSpiHostAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_spi_host_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(SPI_HOST_ALERT_TEST_REG_OFFSET, - {{SPI_HOST_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK( - dif_spi_host_alert_force(&spi_host_, kDifSpiHostAlertFatalFault)); -} - -class IrqGetTypeTest : public SpiHostTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG( - dif_spi_host_irq_get_type(nullptr, kDifSpiHostIrqError, &type)); - - EXPECT_DIF_BADARG( - dif_spi_host_irq_get_type(&spi_host_, kDifSpiHostIrqError, nullptr)); - - EXPECT_DIF_BADARG( - dif_spi_host_irq_get_type(nullptr, kDifSpiHostIrqError, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_spi_host_irq_get_type( - &spi_host_, static_cast(kDifSpiHostIrqSpiEvent + 1), - &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK( - dif_spi_host_irq_get_type(&spi_host_, kDifSpiHostIrqError, &type)); - EXPECT_EQ(type, kDifIrqTypeEvent); -} - -class IrqGetStateTest : public SpiHostTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_spi_host_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_spi_host_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_spi_host_irq_get_state(&spi_host_, nullptr)); - - EXPECT_DIF_BADARG(dif_spi_host_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_spi_host_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(SPI_HOST_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_spi_host_irq_get_state(&spi_host_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public SpiHostTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG( - dif_spi_host_irq_is_pending(nullptr, kDifSpiHostIrqError, &is_pending)); - - EXPECT_DIF_BADARG( - dif_spi_host_irq_is_pending(&spi_host_, kDifSpiHostIrqError, nullptr)); - - EXPECT_DIF_BADARG( - dif_spi_host_irq_is_pending(nullptr, kDifSpiHostIrqError, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_spi_host_irq_is_pending( - &spi_host_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(SPI_HOST_INTR_STATE_REG_OFFSET, - {{SPI_HOST_INTR_STATE_ERROR_BIT, true}}); - EXPECT_DIF_OK( - dif_spi_host_irq_is_pending(&spi_host_, kDifSpiHostIrqError, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(SPI_HOST_INTR_STATE_REG_OFFSET, - {{SPI_HOST_INTR_STATE_SPI_EVENT_BIT, false}}); - EXPECT_DIF_OK(dif_spi_host_irq_is_pending(&spi_host_, kDifSpiHostIrqSpiEvent, - &irq_state)); - 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) { - constexpr uint32_t num_irqs = 2; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_spi_host_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(SPI_HOST_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_spi_host_irq_acknowledge_all(&spi_host_)); -} - -class IrqAcknowledgeTest : public SpiHostTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG(dif_spi_host_irq_acknowledge(nullptr, kDifSpiHostIrqError)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG(dif_spi_host_irq_acknowledge( - nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(SPI_HOST_INTR_STATE_REG_OFFSET, - {{SPI_HOST_INTR_STATE_ERROR_BIT, true}}); - EXPECT_DIF_OK(dif_spi_host_irq_acknowledge(&spi_host_, kDifSpiHostIrqError)); - - // Clear the last IRQ state. - EXPECT_WRITE32(SPI_HOST_INTR_STATE_REG_OFFSET, - {{SPI_HOST_INTR_STATE_SPI_EVENT_BIT, true}}); - EXPECT_DIF_OK( - dif_spi_host_irq_acknowledge(&spi_host_, kDifSpiHostIrqSpiEvent)); -} - -class IrqForceTest : public SpiHostTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_spi_host_irq_force(nullptr, kDifSpiHostIrqError, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG(dif_spi_host_irq_force( - nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(SPI_HOST_INTR_TEST_REG_OFFSET, - {{SPI_HOST_INTR_TEST_ERROR_BIT, true}}); - EXPECT_DIF_OK(dif_spi_host_irq_force(&spi_host_, kDifSpiHostIrqError, true)); - - // Force last IRQ. - EXPECT_WRITE32(SPI_HOST_INTR_TEST_REG_OFFSET, - {{SPI_HOST_INTR_TEST_SPI_EVENT_BIT, true}}); - EXPECT_DIF_OK( - dif_spi_host_irq_force(&spi_host_, kDifSpiHostIrqSpiEvent, true)); -} - -class IrqGetEnabledTest : public SpiHostTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG( - dif_spi_host_irq_get_enabled(nullptr, kDifSpiHostIrqError, &irq_state)); - - EXPECT_DIF_BADARG( - dif_spi_host_irq_get_enabled(&spi_host_, kDifSpiHostIrqError, nullptr)); - - EXPECT_DIF_BADARG( - dif_spi_host_irq_get_enabled(nullptr, kDifSpiHostIrqError, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_spi_host_irq_get_enabled( - &spi_host_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(SPI_HOST_INTR_ENABLE_REG_OFFSET, - {{SPI_HOST_INTR_ENABLE_ERROR_BIT, true}}); - EXPECT_DIF_OK(dif_spi_host_irq_get_enabled(&spi_host_, kDifSpiHostIrqError, - &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(SPI_HOST_INTR_ENABLE_REG_OFFSET, - {{SPI_HOST_INTR_ENABLE_SPI_EVENT_BIT, false}}); - EXPECT_DIF_OK(dif_spi_host_irq_get_enabled(&spi_host_, kDifSpiHostIrqSpiEvent, - &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public SpiHostTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG( - dif_spi_host_irq_set_enabled(nullptr, kDifSpiHostIrqError, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_spi_host_irq_set_enabled( - &spi_host_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(SPI_HOST_INTR_ENABLE_REG_OFFSET, - {{SPI_HOST_INTR_ENABLE_ERROR_BIT, 0x1, true}}); - EXPECT_DIF_OK( - dif_spi_host_irq_set_enabled(&spi_host_, kDifSpiHostIrqError, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(SPI_HOST_INTR_ENABLE_REG_OFFSET, - {{SPI_HOST_INTR_ENABLE_SPI_EVENT_BIT, 0x1, false}}); - EXPECT_DIF_OK(dif_spi_host_irq_set_enabled(&spi_host_, kDifSpiHostIrqSpiEvent, - irq_state)); -} - -class IrqDisableAllTest : public SpiHostTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_spi_host_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_spi_host_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_spi_host_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(SPI_HOST_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_spi_host_irq_disable_all(&spi_host_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_spi_host_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(SPI_HOST_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(SPI_HOST_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_spi_host_irq_disable_all(&spi_host_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_spi_host_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(SPI_HOST_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(SPI_HOST_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_spi_host_irq_disable_all(&spi_host_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public SpiHostTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_spi_host_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_spi_host_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_spi_host_irq_restore_all(&spi_host_, nullptr)); - - EXPECT_DIF_BADARG(dif_spi_host_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_spi_host_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(SPI_HOST_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_spi_host_irq_restore_all(&spi_host_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_spi_host_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(SPI_HOST_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_spi_host_irq_restore_all(&spi_host_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_spi_host_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_sram_ctrl_autogen.c b/sw/device/lib/dif/autogen/dif_sram_ctrl_autogen.c deleted file mode 100644 index ac1d9a8eb486e..0000000000000 --- a/sw/device/lib/dif/autogen/dif_sram_ctrl_autogen.c +++ /dev/null @@ -1,49 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_sram_ctrl_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "sram_ctrl_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sram_ctrl_init(mmio_region_t base_addr, - dif_sram_ctrl_t *sram_ctrl) { - if (sram_ctrl == NULL) { - return kDifBadArg; - } - - sram_ctrl->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_sram_ctrl_alert_force(const dif_sram_ctrl_t *sram_ctrl, - dif_sram_ctrl_alert_t alert) { - if (sram_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifSramCtrlAlertFatalError: - alert_idx = SRAM_CTRL_ALERT_TEST_FATAL_ERROR_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(sram_ctrl->base_addr, - (ptrdiff_t)SRAM_CTRL_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_sram_ctrl_autogen.h b/sw/device/lib/dif/autogen/dif_sram_ctrl_autogen.h deleted file mode 100644 index 63bfd002aa1d5..0000000000000 --- a/sw/device/lib/dif/autogen/dif_sram_ctrl_autogen.h +++ /dev/null @@ -1,80 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_SRAM_CTRL_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_SRAM_CTRL_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief SRAM_CTRL Device Interface - * Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to sram_ctrl. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_sram_ctrl { - /** - * The base address for the sram_ctrl hardware registers. - */ - mmio_region_t base_addr; -} dif_sram_ctrl_t; - -/** - * Creates a new handle for a(n) sram_ctrl peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the sram_ctrl peripheral. - * @param[out] sram_ctrl Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sram_ctrl_init(mmio_region_t base_addr, - dif_sram_ctrl_t *sram_ctrl); - -/** - * A sram_ctrl alert type. - */ -typedef enum dif_sram_ctrl_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected, or if the initialization mechanism has reached an invalid state. - */ - kDifSramCtrlAlertFatalError = 0, -} dif_sram_ctrl_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param sram_ctrl A sram_ctrl handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sram_ctrl_alert_force(const dif_sram_ctrl_t *sram_ctrl, - dif_sram_ctrl_alert_t alert); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_SRAM_CTRL_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_sram_ctrl_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_sram_ctrl_autogen_unittest.cc deleted file mode 100644 index b39cc530d548f..0000000000000 --- a/sw/device/lib/dif/autogen/dif_sram_ctrl_autogen_unittest.cc +++ /dev/null @@ -1,60 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_sram_ctrl_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "sram_ctrl_regs.h" // Generated. - -namespace dif_sram_ctrl_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class SramCtrlTest : public Test, public MmioTest { - protected: - dif_sram_ctrl_t sram_ctrl_ = {.base_addr = dev().region()}; -}; - -class InitTest : public SramCtrlTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_sram_ctrl_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_sram_ctrl_init(dev().region(), &sram_ctrl_)); -} - -class AlertForceTest : public SramCtrlTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_sram_ctrl_alert_force(nullptr, kDifSramCtrlAlertFatalError)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG(dif_sram_ctrl_alert_force( - nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(SRAM_CTRL_ALERT_TEST_REG_OFFSET, - {{SRAM_CTRL_ALERT_TEST_FATAL_ERROR_BIT, true}}); - EXPECT_DIF_OK( - dif_sram_ctrl_alert_force(&sram_ctrl_, kDifSramCtrlAlertFatalError)); -} - -} // namespace -} // namespace dif_sram_ctrl_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen.c b/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen.c deleted file mode 100644 index 0f27a7f360f29..0000000000000 --- a/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen.c +++ /dev/null @@ -1,270 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "sysrst_ctrl_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_init(mmio_region_t base_addr, - dif_sysrst_ctrl_t *sysrst_ctrl) { - if (sysrst_ctrl == NULL) { - return kDifBadArg; - } - - sysrst_ctrl->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_sysrst_ctrl_alert_force(const dif_sysrst_ctrl_t *sysrst_ctrl, - dif_sysrst_ctrl_alert_t alert) { - if (sysrst_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifSysrstCtrlAlertFatalFault: - alert_idx = SYSRST_CTRL_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(sysrst_ctrl->base_addr, - (ptrdiff_t)SYSRST_CTRL_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool sysrst_ctrl_get_irq_bit_index(dif_sysrst_ctrl_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifSysrstCtrlIrqEventDetected: - *index_out = SYSRST_CTRL_INTR_COMMON_EVENT_DETECTED_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeStatus, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_get_type(const dif_sysrst_ctrl_t *sysrst_ctrl, - dif_sysrst_ctrl_irq_t irq, - dif_irq_type_t *type) { - if (sysrst_ctrl == NULL || type == NULL || irq < 0 || - irq > kDifSysrstCtrlIrqEventDetected) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_get_state( - const dif_sysrst_ctrl_t *sysrst_ctrl, - dif_sysrst_ctrl_irq_state_snapshot_t *snapshot) { - if (sysrst_ctrl == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(sysrst_ctrl->base_addr, - (ptrdiff_t)SYSRST_CTRL_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, - (ptrdiff_t)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) { - if (sysrst_ctrl == NULL || is_pending == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!sysrst_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - sysrst_ctrl->base_addr, (ptrdiff_t)SYSRST_CTRL_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_acknowledge_all( - const dif_sysrst_ctrl_t *sysrst_ctrl) { - if (sysrst_ctrl == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(sysrst_ctrl->base_addr, - (ptrdiff_t)SYSRST_CTRL_INTR_STATE_REG_OFFSET, UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_acknowledge( - const dif_sysrst_ctrl_t *sysrst_ctrl, dif_sysrst_ctrl_irq_t irq) { - if (sysrst_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!sysrst_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(sysrst_ctrl->base_addr, - (ptrdiff_t)SYSRST_CTRL_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_force(const dif_sysrst_ctrl_t *sysrst_ctrl, - dif_sysrst_ctrl_irq_t irq, - const bool val) { - if (sysrst_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!sysrst_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(sysrst_ctrl->base_addr, - (ptrdiff_t)SYSRST_CTRL_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_get_enabled( - const dif_sysrst_ctrl_t *sysrst_ctrl, dif_sysrst_ctrl_irq_t irq, - dif_toggle_t *state) { - if (sysrst_ctrl == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!sysrst_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - sysrst_ctrl->base_addr, (ptrdiff_t)SYSRST_CTRL_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_set_enabled( - const dif_sysrst_ctrl_t *sysrst_ctrl, dif_sysrst_ctrl_irq_t irq, - dif_toggle_t state) { - if (sysrst_ctrl == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!sysrst_ctrl_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - sysrst_ctrl->base_addr, (ptrdiff_t)SYSRST_CTRL_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(sysrst_ctrl->base_addr, - (ptrdiff_t)SYSRST_CTRL_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_disable_all( - const dif_sysrst_ctrl_t *sysrst_ctrl, - dif_sysrst_ctrl_irq_enable_snapshot_t *snapshot) { - if (sysrst_ctrl == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32( - sysrst_ctrl->base_addr, (ptrdiff_t)SYSRST_CTRL_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(sysrst_ctrl->base_addr, - (ptrdiff_t)SYSRST_CTRL_INTR_ENABLE_REG_OFFSET, 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_restore_all( - const dif_sysrst_ctrl_t *sysrst_ctrl, - const dif_sysrst_ctrl_irq_enable_snapshot_t *snapshot) { - if (sysrst_ctrl == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(sysrst_ctrl->base_addr, - (ptrdiff_t)SYSRST_CTRL_INTR_ENABLE_REG_OFFSET, *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen.h b/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen.h deleted file mode 100644 index 08488dacdd355..0000000000000 --- a/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen.h +++ /dev/null @@ -1,246 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_SYSRST_CTRL_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_SYSRST_CTRL_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief SYSRST_CTRL Device Interface - * Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to sysrst_ctrl. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_sysrst_ctrl { - /** - * The base address for the sysrst_ctrl hardware registers. - */ - mmio_region_t base_addr; -} dif_sysrst_ctrl_t; - -/** - * Creates a new handle for a(n) sysrst_ctrl peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the sysrst_ctrl peripheral. - * @param[out] sysrst_ctrl Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_init(mmio_region_t base_addr, - dif_sysrst_ctrl_t *sysrst_ctrl); - -/** - * A sysrst_ctrl alert type. - */ -typedef enum dif_sysrst_ctrl_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifSysrstCtrlAlertFatalFault = 0, -} dif_sysrst_ctrl_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param sysrst_ctrl A sysrst_ctrl handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_alert_force(const dif_sysrst_ctrl_t *sysrst_ctrl, - dif_sysrst_ctrl_alert_t alert); - -/** - * A sysrst_ctrl interrupt request type. - */ -typedef enum dif_sysrst_ctrl_irq { - /** - * Common interrupt triggered by combo or keyboard events. - */ - kDifSysrstCtrlIrqEventDetected = 0, -} dif_sysrst_ctrl_irq_t; - -/** - * 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()` - * and `dif_sysrst_ctrl_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_sysrst_ctrl_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param sysrst_ctrl A sysrst_ctrl handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_get_type(const dif_sysrst_ctrl_t *sysrst_ctrl, - dif_sysrst_ctrl_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param sysrst_ctrl A sysrst_ctrl handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_get_state( - const dif_sysrst_ctrl_t *sysrst_ctrl, - dif_sysrst_ctrl_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param sysrst_ctrl A sysrst_ctrl handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param sysrst_ctrl A sysrst_ctrl handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_acknowledge_all( - const dif_sysrst_ctrl_t *sysrst_ctrl); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param sysrst_ctrl A sysrst_ctrl handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_acknowledge( - const dif_sysrst_ctrl_t *sysrst_ctrl, dif_sysrst_ctrl_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param sysrst_ctrl A sysrst_ctrl handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_force(const dif_sysrst_ctrl_t *sysrst_ctrl, - dif_sysrst_ctrl_irq_t irq, - const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_sysrst_ctrl_irq_disable_all()` and `dif_sysrst_ctrl_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_sysrst_ctrl_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param sysrst_ctrl A sysrst_ctrl handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_get_enabled( - const dif_sysrst_ctrl_t *sysrst_ctrl, dif_sysrst_ctrl_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param sysrst_ctrl A sysrst_ctrl handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_set_enabled( - const dif_sysrst_ctrl_t *sysrst_ctrl, dif_sysrst_ctrl_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param sysrst_ctrl A sysrst_ctrl handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_disable_all( - const dif_sysrst_ctrl_t *sysrst_ctrl, - dif_sysrst_ctrl_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param sysrst_ctrl A sysrst_ctrl handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_sysrst_ctrl_irq_restore_all( - const dif_sysrst_ctrl_t *sysrst_ctrl, - const dif_sysrst_ctrl_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_SYSRST_CTRL_AUTOGEN_H_ 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 deleted file mode 100644 index 057066d5ce6d6..0000000000000 --- a/sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen_unittest.cc +++ /dev/null @@ -1,362 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_sysrst_ctrl_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "sysrst_ctrl_regs.h" // Generated. - -namespace dif_sysrst_ctrl_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class SysrstCtrlTest : public Test, public MmioTest { - protected: - dif_sysrst_ctrl_t sysrst_ctrl_ = {.base_addr = dev().region()}; -}; - -class InitTest : public SysrstCtrlTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_sysrst_ctrl_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_sysrst_ctrl_init(dev().region(), &sysrst_ctrl_)); -} - -class AlertForceTest : public SysrstCtrlTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_sysrst_ctrl_alert_force(nullptr, kDifSysrstCtrlAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG(dif_sysrst_ctrl_alert_force( - nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(SYSRST_CTRL_ALERT_TEST_REG_OFFSET, - {{SYSRST_CTRL_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_sysrst_ctrl_alert_force(&sysrst_ctrl_, - kDifSysrstCtrlAlertFatalFault)); -} - -class IrqGetTypeTest : public SysrstCtrlTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_get_type( - nullptr, kDifSysrstCtrlIrqEventDetected, &type)); - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_get_type( - &sysrst_ctrl_, kDifSysrstCtrlIrqEventDetected, nullptr)); - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_get_type( - nullptr, kDifSysrstCtrlIrqEventDetected, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_get_type( - &sysrst_ctrl_, - static_cast(kDifSysrstCtrlIrqEventDetected + 1), - &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_sysrst_ctrl_irq_get_type( - &sysrst_ctrl_, kDifSysrstCtrlIrqEventDetected, &type)); - EXPECT_EQ(type, kDifIrqTypeStatus); -} - -class IrqGetStateTest : public SysrstCtrlTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_sysrst_ctrl_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_get_state(&sysrst_ctrl_, nullptr)); - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_sysrst_ctrl_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(SYSRST_CTRL_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_sysrst_ctrl_irq_get_state(&sysrst_ctrl_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public SysrstCtrlTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_is_pending( - nullptr, kDifSysrstCtrlIrqEventDetected, &is_pending)); - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_is_pending( - &sysrst_ctrl_, kDifSysrstCtrlIrqEventDetected, nullptr)); - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_is_pending( - nullptr, kDifSysrstCtrlIrqEventDetected, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_is_pending( - &sysrst_ctrl_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(SYSRST_CTRL_INTR_STATE_REG_OFFSET, - {{SYSRST_CTRL_INTR_STATE_EVENT_DETECTED_BIT, true}}); - EXPECT_DIF_OK(dif_sysrst_ctrl_irq_is_pending( - &sysrst_ctrl_, kDifSysrstCtrlIrqEventDetected, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 1; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(SYSRST_CTRL_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_sysrst_ctrl_irq_acknowledge_all(&sysrst_ctrl_)); -} - -class IrqAcknowledgeTest : public SysrstCtrlTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_sysrst_ctrl_irq_acknowledge(nullptr, kDifSysrstCtrlIrqEventDetected)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_acknowledge( - nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(SYSRST_CTRL_INTR_STATE_REG_OFFSET, - {{SYSRST_CTRL_INTR_STATE_EVENT_DETECTED_BIT, true}}); - EXPECT_DIF_OK(dif_sysrst_ctrl_irq_acknowledge( - &sysrst_ctrl_, kDifSysrstCtrlIrqEventDetected)); -} - -class IrqForceTest : public SysrstCtrlTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_sysrst_ctrl_irq_force(nullptr, kDifSysrstCtrlIrqEventDetected, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_force( - nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(SYSRST_CTRL_INTR_TEST_REG_OFFSET, - {{SYSRST_CTRL_INTR_TEST_EVENT_DETECTED_BIT, true}}); - EXPECT_DIF_OK(dif_sysrst_ctrl_irq_force( - &sysrst_ctrl_, kDifSysrstCtrlIrqEventDetected, true)); -} - -class IrqGetEnabledTest : public SysrstCtrlTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_get_enabled( - nullptr, kDifSysrstCtrlIrqEventDetected, &irq_state)); - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_get_enabled( - &sysrst_ctrl_, kDifSysrstCtrlIrqEventDetected, nullptr)); - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_get_enabled( - nullptr, kDifSysrstCtrlIrqEventDetected, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_get_enabled( - &sysrst_ctrl_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(SYSRST_CTRL_INTR_ENABLE_REG_OFFSET, - {{SYSRST_CTRL_INTR_ENABLE_EVENT_DETECTED_BIT, true}}); - EXPECT_DIF_OK(dif_sysrst_ctrl_irq_get_enabled( - &sysrst_ctrl_, kDifSysrstCtrlIrqEventDetected, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); -} - -class IrqSetEnabledTest : public SysrstCtrlTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_set_enabled( - nullptr, kDifSysrstCtrlIrqEventDetected, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_set_enabled( - &sysrst_ctrl_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(SYSRST_CTRL_INTR_ENABLE_REG_OFFSET, - {{SYSRST_CTRL_INTR_ENABLE_EVENT_DETECTED_BIT, 0x1, true}}); - EXPECT_DIF_OK(dif_sysrst_ctrl_irq_set_enabled( - &sysrst_ctrl_, kDifSysrstCtrlIrqEventDetected, irq_state)); -} - -class IrqDisableAllTest : public SysrstCtrlTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_sysrst_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(SYSRST_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_sysrst_ctrl_irq_disable_all(&sysrst_ctrl_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_sysrst_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(SYSRST_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(SYSRST_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_sysrst_ctrl_irq_disable_all(&sysrst_ctrl_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_sysrst_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(SYSRST_CTRL_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(SYSRST_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_sysrst_ctrl_irq_disable_all(&sysrst_ctrl_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public SysrstCtrlTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_sysrst_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_restore_all(&sysrst_ctrl_, nullptr)); - - EXPECT_DIF_BADARG(dif_sysrst_ctrl_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_sysrst_ctrl_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(SYSRST_CTRL_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_sysrst_ctrl_irq_restore_all(&sysrst_ctrl_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_sysrst_ctrl_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(SYSRST_CTRL_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_sysrst_ctrl_irq_restore_all(&sysrst_ctrl_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_sysrst_ctrl_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_uart_autogen.c b/sw/device/lib/dif/autogen/dif_uart_autogen.c deleted file mode 100644 index e514a45b6a154..0000000000000 --- a/sw/device/lib/dif/autogen/dif_uart_autogen.c +++ /dev/null @@ -1,280 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_uart_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "uart_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_init(mmio_region_t base_addr, dif_uart_t *uart) { - if (uart == NULL) { - return kDifBadArg; - } - - uart->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_uart_alert_force(const dif_uart_t *uart, - dif_uart_alert_t alert) { - if (uart == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifUartAlertFatalFault: - alert_idx = UART_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(uart->base_addr, (ptrdiff_t)UART_ALERT_TEST_REG_OFFSET, - alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool uart_get_irq_bit_index(dif_uart_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifUartIrqTxWatermark: - *index_out = UART_INTR_COMMON_TX_WATERMARK_BIT; - break; - case kDifUartIrqRxWatermark: - *index_out = UART_INTR_COMMON_RX_WATERMARK_BIT; - break; - case kDifUartIrqTxDone: - *index_out = UART_INTR_COMMON_TX_DONE_BIT; - break; - case kDifUartIrqRxOverflow: - *index_out = UART_INTR_COMMON_RX_OVERFLOW_BIT; - break; - case kDifUartIrqRxFrameErr: - *index_out = UART_INTR_COMMON_RX_FRAME_ERR_BIT; - break; - case kDifUartIrqRxBreakErr: - *index_out = UART_INTR_COMMON_RX_BREAK_ERR_BIT; - break; - case kDifUartIrqRxTimeout: - *index_out = UART_INTR_COMMON_RX_TIMEOUT_BIT; - break; - case kDifUartIrqRxParityErr: - *index_out = UART_INTR_COMMON_RX_PARITY_ERR_BIT; - break; - case kDifUartIrqTxEmpty: - *index_out = UART_INTR_COMMON_TX_EMPTY_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeStatus, kDifIrqTypeStatus, kDifIrqTypeEvent, - kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, - kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeStatus, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_get_type(const dif_uart_t *uart, dif_uart_irq_t irq, - dif_irq_type_t *type) { - if (uart == NULL || type == NULL || irq < 0 || irq > kDifUartIrqTxEmpty) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_get_state(const dif_uart_t *uart, - dif_uart_irq_state_snapshot_t *snapshot) { - if (uart == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(uart->base_addr, - (ptrdiff_t)UART_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, (ptrdiff_t)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) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!uart_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - uart->base_addr, (ptrdiff_t)UART_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_acknowledge_all(const dif_uart_t *uart) { - if (uart == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(uart->base_addr, (ptrdiff_t)UART_INTR_STATE_REG_OFFSET, - UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_acknowledge(const dif_uart_t *uart, - dif_uart_irq_t irq) { - if (uart == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!uart_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(uart->base_addr, (ptrdiff_t)UART_INTR_STATE_REG_OFFSET, - intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_force(const dif_uart_t *uart, dif_uart_irq_t irq, - const bool val) { - if (uart == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!uart_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(uart->base_addr, (ptrdiff_t)UART_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_get_enabled(const dif_uart_t *uart, - dif_uart_irq_t irq, dif_toggle_t *state) { - if (uart == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!uart_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - uart->base_addr, (ptrdiff_t)UART_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_set_enabled(const dif_uart_t *uart, - dif_uart_irq_t irq, dif_toggle_t state) { - if (uart == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!uart_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - uart->base_addr, (ptrdiff_t)UART_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(uart->base_addr, (ptrdiff_t)UART_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_disable_all( - const dif_uart_t *uart, dif_uart_irq_enable_snapshot_t *snapshot) { - if (uart == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(uart->base_addr, - (ptrdiff_t)UART_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(uart->base_addr, (ptrdiff_t)UART_INTR_ENABLE_REG_OFFSET, - 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_restore_all( - const dif_uart_t *uart, const dif_uart_irq_enable_snapshot_t *snapshot) { - if (uart == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(uart->base_addr, (ptrdiff_t)UART_INTR_ENABLE_REG_OFFSET, - *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_uart_autogen.h b/sw/device/lib/dif/autogen/dif_uart_autogen.h deleted file mode 100644 index 84e4b2e83dfc7..0000000000000 --- a/sw/device/lib/dif/autogen/dif_uart_autogen.h +++ /dev/null @@ -1,267 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_UART_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_UART_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief UART Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to uart. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_uart { - /** - * The base address for the uart hardware registers. - */ - mmio_region_t base_addr; -} dif_uart_t; - -/** - * Creates a new handle for a(n) uart peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the uart peripheral. - * @param[out] uart Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_init(mmio_region_t base_addr, dif_uart_t *uart); - -/** - * A uart alert type. - */ -typedef enum dif_uart_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifUartAlertFatalFault = 0, -} dif_uart_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param uart A uart handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_alert_force(const dif_uart_t *uart, - dif_uart_alert_t alert); - -/** - * A uart interrupt request type. - */ -typedef enum dif_uart_irq { - /** - * Raised if the transmit FIFO is past the high-water mark. - */ - kDifUartIrqTxWatermark = 0, - /** - * Raised if the receive FIFO is past the high-water mark. - */ - kDifUartIrqRxWatermark = 1, - /** - * Raised if the transmit FIFO has emptied and no transmit is ongoing. - */ - kDifUartIrqTxDone = 2, - /** - * Raised if the receive FIFO has overflowed. - */ - kDifUartIrqRxOverflow = 3, - /** - * Raised if a framing error has been detected on receive. - */ - kDifUartIrqRxFrameErr = 4, - /** - * Raised if break condition has been detected on receive. - */ - kDifUartIrqRxBreakErr = 5, - /** - * Raised if RX FIFO has characters remaining in the FIFO without being - * retrieved for the programmed time period. - */ - kDifUartIrqRxTimeout = 6, - /** - * Raised if the receiver has detected a parity error. - */ - kDifUartIrqRxParityErr = 7, - /** - * Raised if the transmit FIFO is empty. - */ - kDifUartIrqTxEmpty = 8, -} dif_uart_irq_t; - -/** - * 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()` - * and `dif_uart_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_uart_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param uart A uart handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_get_type(const dif_uart_t *uart, dif_uart_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param uart A uart handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_get_state(const dif_uart_t *uart, - dif_uart_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param uart A uart handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param uart A uart handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_acknowledge_all(const dif_uart_t *uart); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param uart A uart handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_acknowledge(const dif_uart_t *uart, - dif_uart_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param uart A uart handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_force(const dif_uart_t *uart, dif_uart_irq_t irq, - const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_uart_irq_disable_all()` and `dif_uart_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_uart_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param uart A uart handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_get_enabled(const dif_uart_t *uart, - dif_uart_irq_t irq, dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param uart A uart handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_set_enabled(const dif_uart_t *uart, - dif_uart_irq_t irq, dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param uart A uart handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_disable_all(const dif_uart_t *uart, - dif_uart_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param uart A uart handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_uart_irq_restore_all( - const dif_uart_t *uart, const dif_uart_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_UART_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_uart_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_uart_autogen_unittest.cc deleted file mode 100644 index ed5b6d62b5b5e..0000000000000 --- a/sw/device/lib/dif/autogen/dif_uart_autogen_unittest.cc +++ /dev/null @@ -1,384 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_uart_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "uart_regs.h" // Generated. - -namespace dif_uart_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class UartTest : public Test, public MmioTest { - protected: - dif_uart_t uart_ = {.base_addr = dev().region()}; -}; - -class InitTest : public UartTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_uart_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_uart_init(dev().region(), &uart_)); -} - -class AlertForceTest : public UartTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_uart_alert_force(nullptr, kDifUartAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_uart_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(UART_ALERT_TEST_REG_OFFSET, - {{UART_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_uart_alert_force(&uart_, kDifUartAlertFatalFault)); -} - -class IrqGetTypeTest : public UartTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG( - dif_uart_irq_get_type(nullptr, kDifUartIrqTxWatermark, &type)); - - EXPECT_DIF_BADARG( - dif_uart_irq_get_type(&uart_, kDifUartIrqTxWatermark, nullptr)); - - EXPECT_DIF_BADARG( - dif_uart_irq_get_type(nullptr, kDifUartIrqTxWatermark, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_uart_irq_get_type( - &uart_, static_cast(kDifUartIrqTxEmpty + 1), &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK(dif_uart_irq_get_type(&uart_, kDifUartIrqTxWatermark, &type)); - EXPECT_EQ(type, kDifIrqTypeStatus); -} - -class IrqGetStateTest : public UartTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_uart_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_uart_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_uart_irq_get_state(&uart_, nullptr)); - - EXPECT_DIF_BADARG(dif_uart_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_uart_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(UART_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_uart_irq_get_state(&uart_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public UartTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG( - dif_uart_irq_is_pending(nullptr, kDifUartIrqTxWatermark, &is_pending)); - - EXPECT_DIF_BADARG( - dif_uart_irq_is_pending(&uart_, kDifUartIrqTxWatermark, nullptr)); - - EXPECT_DIF_BADARG( - dif_uart_irq_is_pending(nullptr, kDifUartIrqTxWatermark, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_uart_irq_is_pending( - &uart_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(UART_INTR_STATE_REG_OFFSET, - {{UART_INTR_STATE_TX_WATERMARK_BIT, true}}); - EXPECT_DIF_OK( - dif_uart_irq_is_pending(&uart_, kDifUartIrqTxWatermark, &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(UART_INTR_STATE_REG_OFFSET, - {{UART_INTR_STATE_TX_EMPTY_BIT, false}}); - EXPECT_DIF_OK( - dif_uart_irq_is_pending(&uart_, kDifUartIrqTxEmpty, &irq_state)); - 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) { - constexpr uint32_t num_irqs = 9; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_uart_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(UART_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_uart_irq_acknowledge_all(&uart_)); -} - -class IrqAcknowledgeTest : public UartTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG(dif_uart_irq_acknowledge(nullptr, kDifUartIrqTxWatermark)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_uart_irq_acknowledge(nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(UART_INTR_STATE_REG_OFFSET, - {{UART_INTR_STATE_TX_WATERMARK_BIT, true}}); - EXPECT_DIF_OK(dif_uart_irq_acknowledge(&uart_, kDifUartIrqTxWatermark)); - - // Clear the last IRQ state. - EXPECT_WRITE32(UART_INTR_STATE_REG_OFFSET, - {{UART_INTR_STATE_TX_EMPTY_BIT, true}}); - EXPECT_DIF_OK(dif_uart_irq_acknowledge(&uart_, kDifUartIrqTxEmpty)); -} - -class IrqForceTest : public UartTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_uart_irq_force(nullptr, kDifUartIrqTxWatermark, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_uart_irq_force(nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(UART_INTR_TEST_REG_OFFSET, - {{UART_INTR_TEST_TX_WATERMARK_BIT, true}}); - EXPECT_DIF_OK(dif_uart_irq_force(&uart_, kDifUartIrqTxWatermark, true)); - - // Force last IRQ. - EXPECT_WRITE32(UART_INTR_TEST_REG_OFFSET, - {{UART_INTR_TEST_TX_EMPTY_BIT, true}}); - EXPECT_DIF_OK(dif_uart_irq_force(&uart_, kDifUartIrqTxEmpty, true)); -} - -class IrqGetEnabledTest : public UartTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG( - dif_uart_irq_get_enabled(nullptr, kDifUartIrqTxWatermark, &irq_state)); - - EXPECT_DIF_BADARG( - dif_uart_irq_get_enabled(&uart_, kDifUartIrqTxWatermark, nullptr)); - - EXPECT_DIF_BADARG( - dif_uart_irq_get_enabled(nullptr, kDifUartIrqTxWatermark, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_uart_irq_get_enabled( - &uart_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(UART_INTR_ENABLE_REG_OFFSET, - {{UART_INTR_ENABLE_TX_WATERMARK_BIT, true}}); - EXPECT_DIF_OK( - dif_uart_irq_get_enabled(&uart_, kDifUartIrqTxWatermark, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(UART_INTR_ENABLE_REG_OFFSET, - {{UART_INTR_ENABLE_TX_EMPTY_BIT, false}}); - EXPECT_DIF_OK( - dif_uart_irq_get_enabled(&uart_, kDifUartIrqTxEmpty, &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public UartTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG( - dif_uart_irq_set_enabled(nullptr, kDifUartIrqTxWatermark, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_uart_irq_set_enabled( - &uart_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(UART_INTR_ENABLE_REG_OFFSET, - {{UART_INTR_ENABLE_TX_WATERMARK_BIT, 0x1, true}}); - EXPECT_DIF_OK( - dif_uart_irq_set_enabled(&uart_, kDifUartIrqTxWatermark, irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(UART_INTR_ENABLE_REG_OFFSET, - {{UART_INTR_ENABLE_TX_EMPTY_BIT, 0x1, false}}); - EXPECT_DIF_OK( - dif_uart_irq_set_enabled(&uart_, kDifUartIrqTxEmpty, irq_state)); -} - -class IrqDisableAllTest : public UartTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_uart_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_uart_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_uart_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(UART_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_uart_irq_disable_all(&uart_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_uart_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(UART_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(UART_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_uart_irq_disable_all(&uart_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_uart_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(UART_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(UART_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_uart_irq_disable_all(&uart_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public UartTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_uart_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_uart_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_uart_irq_restore_all(&uart_, nullptr)); - - EXPECT_DIF_BADARG(dif_uart_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_uart_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(UART_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_uart_irq_restore_all(&uart_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_uart_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(UART_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_uart_irq_restore_all(&uart_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_uart_autogen_unittest diff --git a/sw/device/lib/dif/autogen/dif_usbdev_autogen.c b/sw/device/lib/dif/autogen/dif_usbdev_autogen.c deleted file mode 100644 index 7c118302d8ce5..0000000000000 --- a/sw/device/lib/dif/autogen/dif_usbdev_autogen.c +++ /dev/null @@ -1,315 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_usbdev_autogen.h" - -#include - -#include "sw/device/lib/dif/dif_base.h" - -#include "usbdev_regs.h" // Generated. - -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_init(mmio_region_t base_addr, dif_usbdev_t *usbdev) { - if (usbdev == NULL) { - return kDifBadArg; - } - - usbdev->base_addr = base_addr; - - return kDifOk; -} - -dif_result_t dif_usbdev_alert_force(const dif_usbdev_t *usbdev, - dif_usbdev_alert_t alert) { - if (usbdev == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t alert_idx; - switch (alert) { - case kDifUsbdevAlertFatalFault: - alert_idx = USBDEV_ALERT_TEST_FATAL_FAULT_BIT; - break; - default: - return kDifBadArg; - } - - uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true); - mmio_region_write32(usbdev->base_addr, - (ptrdiff_t)USBDEV_ALERT_TEST_REG_OFFSET, alert_test_reg); - - return kDifOk; -} - -/** - * Get the corresponding interrupt register bit offset of the IRQ. - */ -static bool usbdev_get_irq_bit_index(dif_usbdev_irq_t irq, - bitfield_bit32_index_t *index_out) { - switch (irq) { - case kDifUsbdevIrqPktReceived: - *index_out = USBDEV_INTR_COMMON_PKT_RECEIVED_BIT; - break; - case kDifUsbdevIrqPktSent: - *index_out = USBDEV_INTR_COMMON_PKT_SENT_BIT; - break; - case kDifUsbdevIrqDisconnected: - *index_out = USBDEV_INTR_COMMON_DISCONNECTED_BIT; - break; - case kDifUsbdevIrqHostLost: - *index_out = USBDEV_INTR_COMMON_HOST_LOST_BIT; - break; - case kDifUsbdevIrqLinkReset: - *index_out = USBDEV_INTR_COMMON_LINK_RESET_BIT; - break; - case kDifUsbdevIrqLinkSuspend: - *index_out = USBDEV_INTR_COMMON_LINK_SUSPEND_BIT; - break; - case kDifUsbdevIrqLinkResume: - *index_out = USBDEV_INTR_COMMON_LINK_RESUME_BIT; - break; - case kDifUsbdevIrqAvOutEmpty: - *index_out = USBDEV_INTR_COMMON_AV_OUT_EMPTY_BIT; - break; - case kDifUsbdevIrqRxFull: - *index_out = USBDEV_INTR_COMMON_RX_FULL_BIT; - break; - case kDifUsbdevIrqAvOverflow: - *index_out = USBDEV_INTR_COMMON_AV_OVERFLOW_BIT; - break; - case kDifUsbdevIrqLinkInErr: - *index_out = USBDEV_INTR_COMMON_LINK_IN_ERR_BIT; - break; - case kDifUsbdevIrqRxCrcErr: - *index_out = USBDEV_INTR_COMMON_RX_CRC_ERR_BIT; - break; - case kDifUsbdevIrqRxPidErr: - *index_out = USBDEV_INTR_COMMON_RX_PID_ERR_BIT; - break; - case kDifUsbdevIrqRxBitstuffErr: - *index_out = USBDEV_INTR_COMMON_RX_BITSTUFF_ERR_BIT; - break; - case kDifUsbdevIrqFrame: - *index_out = USBDEV_INTR_COMMON_FRAME_BIT; - break; - case kDifUsbdevIrqPowered: - *index_out = USBDEV_INTR_COMMON_POWERED_BIT; - break; - case kDifUsbdevIrqLinkOutErr: - *index_out = USBDEV_INTR_COMMON_LINK_OUT_ERR_BIT; - break; - case kDifUsbdevIrqAvSetupEmpty: - *index_out = USBDEV_INTR_COMMON_AV_SETUP_EMPTY_BIT; - break; - default: - return false; - } - - return true; -} - -static dif_irq_type_t irq_types[] = { - kDifIrqTypeStatus, kDifIrqTypeStatus, kDifIrqTypeEvent, kDifIrqTypeEvent, - kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeStatus, - kDifIrqTypeStatus, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, - kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, - kDifIrqTypeEvent, kDifIrqTypeStatus, -}; - -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_get_type(const dif_usbdev_t *usbdev, - dif_usbdev_irq_t irq, - dif_irq_type_t *type) { - if (usbdev == NULL || type == NULL || irq < 0 || - irq > kDifUsbdevIrqAvSetupEmpty) { - return kDifBadArg; - } - - *type = irq_types[irq]; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_get_state( - const dif_usbdev_t *usbdev, dif_usbdev_irq_state_snapshot_t *snapshot) { - if (usbdev == NULL || snapshot == NULL) { - return kDifBadArg; - } - - *snapshot = mmio_region_read32(usbdev->base_addr, - (ptrdiff_t)USBDEV_INTR_STATE_REG_OFFSET); - - return kDifOk; -} - -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, - (ptrdiff_t)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) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!usbdev_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_state_reg = mmio_region_read32( - usbdev->base_addr, (ptrdiff_t)USBDEV_INTR_STATE_REG_OFFSET); - - *is_pending = bitfield_bit32_read(intr_state_reg, index); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_acknowledge_all(const dif_usbdev_t *usbdev) { - if (usbdev == NULL) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - mmio_region_write32(usbdev->base_addr, - (ptrdiff_t)USBDEV_INTR_STATE_REG_OFFSET, UINT32_MAX); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_acknowledge(const dif_usbdev_t *usbdev, - dif_usbdev_irq_t irq) { - if (usbdev == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!usbdev_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - // Writing to the register clears the corresponding bits (Write-one clear). - uint32_t intr_state_reg = bitfield_bit32_write(0, index, true); - mmio_region_write32(usbdev->base_addr, - (ptrdiff_t)USBDEV_INTR_STATE_REG_OFFSET, intr_state_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_force(const dif_usbdev_t *usbdev, - dif_usbdev_irq_t irq, const bool val) { - if (usbdev == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!usbdev_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_test_reg = bitfield_bit32_write(0, index, val); - mmio_region_write32(usbdev->base_addr, (ptrdiff_t)USBDEV_INTR_TEST_REG_OFFSET, - intr_test_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_get_enabled(const dif_usbdev_t *usbdev, - dif_usbdev_irq_t irq, - dif_toggle_t *state) { - if (usbdev == NULL || state == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!usbdev_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - usbdev->base_addr, (ptrdiff_t)USBDEV_INTR_ENABLE_REG_OFFSET); - - bool is_enabled = bitfield_bit32_read(intr_enable_reg, index); - *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled; - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_set_enabled(const dif_usbdev_t *usbdev, - dif_usbdev_irq_t irq, - dif_toggle_t state) { - if (usbdev == NULL) { - return kDifBadArg; - } - - bitfield_bit32_index_t index; - if (!usbdev_get_irq_bit_index(irq, &index)) { - return kDifBadArg; - } - - uint32_t intr_enable_reg = mmio_region_read32( - usbdev->base_addr, (ptrdiff_t)USBDEV_INTR_ENABLE_REG_OFFSET); - - bool enable_bit = (state == kDifToggleEnabled) ? true : false; - intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit); - mmio_region_write32(usbdev->base_addr, - (ptrdiff_t)USBDEV_INTR_ENABLE_REG_OFFSET, - intr_enable_reg); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_disable_all( - const dif_usbdev_t *usbdev, dif_usbdev_irq_enable_snapshot_t *snapshot) { - if (usbdev == NULL) { - return kDifBadArg; - } - - // Pass the current interrupt state to the caller, if requested. - if (snapshot != NULL) { - *snapshot = mmio_region_read32(usbdev->base_addr, - (ptrdiff_t)USBDEV_INTR_ENABLE_REG_OFFSET); - } - - // Disable all interrupts. - mmio_region_write32(usbdev->base_addr, - (ptrdiff_t)USBDEV_INTR_ENABLE_REG_OFFSET, 0u); - - return kDifOk; -} - -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_restore_all( - const dif_usbdev_t *usbdev, - const dif_usbdev_irq_enable_snapshot_t *snapshot) { - if (usbdev == NULL || snapshot == NULL) { - return kDifBadArg; - } - - mmio_region_write32(usbdev->base_addr, - (ptrdiff_t)USBDEV_INTR_ENABLE_REG_OFFSET, *snapshot); - - return kDifOk; -} diff --git a/sw/device/lib/dif/autogen/dif_usbdev_autogen.h b/sw/device/lib/dif/autogen/dif_usbdev_autogen.h deleted file mode 100644 index eb977b1bfd97b..0000000000000 --- a/sw/device/lib/dif/autogen/dif_usbdev_autogen.h +++ /dev/null @@ -1,332 +0,0 @@ -// Copyright lowRISC contributors (OpenTitan project). -// Licensed under the Apache License, Version 2.0, see LICENSE for details. -// SPDX-License-Identifier: Apache-2.0 - -#ifndef OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_USBDEV_AUTOGEN_H_ -#define OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_USBDEV_AUTOGEN_H_ - -// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND: -// util/make_new_dif.py --mode=regen --only=autogen - -/** - * @file - * @brief USBDEV Device Interface Functions - */ - -#include -#include - -#include "sw/device/lib/base/macros.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/dif/dif_base.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -/** - * A handle to usbdev. - * - * This type should be treated as opaque by users. - */ -typedef struct dif_usbdev { - /** - * The base address for the usbdev hardware registers. - */ - mmio_region_t base_addr; -} dif_usbdev_t; - -/** - * Creates a new handle for a(n) usbdev peripheral. - * - * This function does not actuate the hardware. - * - * @param base_addr The MMIO base address of the usbdev peripheral. - * @param[out] usbdev Out param for the initialized handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_init(mmio_region_t base_addr, dif_usbdev_t *usbdev); - -/** - * A usbdev alert type. - */ -typedef enum dif_usbdev_alert { - /** - * This fatal alert is triggered when a fatal TL-UL bus integrity fault is - * detected. - */ - kDifUsbdevAlertFatalFault = 0, -} dif_usbdev_alert_t; - -/** - * Forces a particular alert, causing it to be escalated as if the hardware - * had raised it. - * - * @param usbdev A usbdev handle. - * @param alert The alert to force. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_alert_force(const dif_usbdev_t *usbdev, - dif_usbdev_alert_t alert); - -/** - * A usbdev interrupt request type. - */ -typedef enum dif_usbdev_irq { - /** - * Raised if a packet was received using an OUT or SETUP transaction. This - * interrupt is directly tied to whether the RX FIFO is empty, so it should be - * cleared only after handling the FIFO entry. - */ - kDifUsbdevIrqPktReceived = 0, - /** - * Raised if a packet was sent as part of an IN transaction. This interrupt is - * directly tied to whether a sent packet has not been acknowledged in the - * !!in_sent register. It should be cleared only after clearing all bits in - * the !!in_sent register. - */ - kDifUsbdevIrqPktSent = 1, - /** - * Raised if VBUS is lost, thus the link is disconnected. - */ - kDifUsbdevIrqDisconnected = 2, - /** - * Raised if link is active but SOF was not received from host for 4.096 ms. - * The SOF should be every 1 ms. - */ - kDifUsbdevIrqHostLost = 3, - /** - * Raised if the link is at SE0 longer than 3 us indicating a link reset (host - * asserts for min 10 ms, device can react after 2.5 us). - */ - kDifUsbdevIrqLinkReset = 4, - /** - * Raised if the line has signaled J for longer than 3ms and is therefore in - * suspend state. - */ - kDifUsbdevIrqLinkSuspend = 5, - /** - * Raised when the link becomes active again after being suspended. - */ - kDifUsbdevIrqLinkResume = 6, - /** - * Raised when the Available OUT Buffer FIFO is empty and the device interface - * is enabled. This interrupt is directly tied to the FIFO status, so the - * Available OUT Buffer FIFO must be provided with a free buffer before the - * interrupt can be cleared. - */ - kDifUsbdevIrqAvOutEmpty = 7, - /** - * Raised when the RX FIFO is full and the device interface is enabled. This - * interrupt is directly tied to the FIFO status, so the RX FIFO must have an - * entry removed before the interrupt is cleared. If the condition is not - * cleared, the interrupt can re-assert. - */ - kDifUsbdevIrqRxFull = 8, - /** - * Raised if a write was done to either the Available OUT Buffer FIFO or the - * Available SETUP Buffer FIFO when the FIFO was full. - */ - kDifUsbdevIrqAvOverflow = 9, - /** - * Raised if a packet to an IN endpoint started to be received but was then - * dropped due to an error. After transmitting the IN payload, the USB device - * expects a valid ACK handshake packet. This error is raised if either the - * packet or CRC is invalid, leading to a NAK instead, or if a different token - * was received. - */ - kDifUsbdevIrqLinkInErr = 10, - /** - * Raised if a CRC error occurred on a received packet. - */ - kDifUsbdevIrqRxCrcErr = 11, - /** - * Raised if an invalid Packet IDentifier (PID) was received. - */ - kDifUsbdevIrqRxPidErr = 12, - /** - * Raised if an invalid bitstuffing was received. - */ - kDifUsbdevIrqRxBitstuffErr = 13, - /** - * Raised when the USB frame number is updated with a valid SOF. - */ - kDifUsbdevIrqFrame = 14, - /** - * Raised if VBUS is applied. - */ - kDifUsbdevIrqPowered = 15, - /** - * Raised if a packet to an OUT endpoint started to be received but was then - * dropped due to an error. This error is raised if the data toggle, token, - * packet and/or CRC are invalid, or if the appropriate Available OUT Buffer - * FIFO is empty and/or the Received Buffer FIFO is full when a packet should - * have been received. - */ - kDifUsbdevIrqLinkOutErr = 16, - /** - * Raised when the Available SETUP Buffer FIFO is empty and the device - * interface is enabled. This interrupt is directly tied to the FIFO status, - * so the Available SETUP Buffer FIFO must be provided with a free buffer - * before the interrupt can be cleared. - */ - kDifUsbdevIrqAvSetupEmpty = 17, -} dif_usbdev_irq_t; - -/** - * 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()` - * and `dif_usbdev_irq_acknowledge_state()` functions. - */ -typedef uint32_t dif_usbdev_irq_state_snapshot_t; - -/** - * Returns the type of a given interrupt (i.e., event or status) for this IP. - * - * @param usbdev A usbdev handle. - * @param irq An interrupt request. - * @param[out] type Out-param for the interrupt type. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_get_type(const dif_usbdev_t *usbdev, - dif_usbdev_irq_t irq, - dif_irq_type_t *type); - -/** - * Returns the state of all interrupts (i.e., pending or not) for this IP. - * - * @param usbdev A usbdev handle. - * @param[out] snapshot Out-param for interrupt state snapshot. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_get_state( - const dif_usbdev_t *usbdev, dif_usbdev_irq_state_snapshot_t *snapshot); - -/** - * Returns whether a particular interrupt is currently pending. - * - * @param usbdev A usbdev handle. - * @param irq An interrupt request. - * @param[out] is_pending Out-param for whether the interrupt is pending. - * @return The result of the operation. - */ -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); - -/** - * 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. - * - * @param usbdev A usbdev handle. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_acknowledge_all(const dif_usbdev_t *usbdev); - -/** - * Acknowledges a particular interrupt, indicating to the hardware that it has - * been successfully serviced. - * - * @param usbdev A usbdev handle. - * @param irq An interrupt request. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_acknowledge(const dif_usbdev_t *usbdev, - dif_usbdev_irq_t irq); - -/** - * Forces a particular interrupt, causing it to be serviced as if hardware had - * asserted it. - * - * @param usbdev A usbdev handle. - * @param irq An interrupt request. - * @param val Value to be set. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_force(const dif_usbdev_t *usbdev, - dif_usbdev_irq_t irq, const bool val); - -/** - * A snapshot of the enablement state of the interrupts for this IP. - * - * This is an opaque type, to be used with the - * `dif_usbdev_irq_disable_all()` and `dif_usbdev_irq_restore_all()` - * functions. - */ -typedef uint32_t dif_usbdev_irq_enable_snapshot_t; - -/** - * Checks whether a particular interrupt is currently enabled or disabled. - * - * @param usbdev A usbdev handle. - * @param irq An interrupt request. - * @param[out] state Out-param toggle state of the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_get_enabled(const dif_usbdev_t *usbdev, - dif_usbdev_irq_t irq, - dif_toggle_t *state); - -/** - * Sets whether a particular interrupt is currently enabled or disabled. - * - * @param usbdev A usbdev handle. - * @param irq An interrupt request. - * @param state The new toggle state for the interrupt. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_set_enabled(const dif_usbdev_t *usbdev, - dif_usbdev_irq_t irq, - dif_toggle_t state); - -/** - * Disables all interrupts, optionally snapshotting all enable states for later - * restoration. - * - * @param usbdev A usbdev handle. - * @param[out] snapshot Out-param for the snapshot; may be `NULL`. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_disable_all( - const dif_usbdev_t *usbdev, dif_usbdev_irq_enable_snapshot_t *snapshot); - -/** - * Restores interrupts from the given (enable) snapshot. - * - * @param usbdev A usbdev handle. - * @param snapshot A snapshot to restore from. - * @return The result of the operation. - */ -OT_WARN_UNUSED_RESULT -dif_result_t dif_usbdev_irq_restore_all( - const dif_usbdev_t *usbdev, - const dif_usbdev_irq_enable_snapshot_t *snapshot); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // OPENTITAN_SW_DEVICE_LIB_DIF_AUTOGEN_DIF_USBDEV_AUTOGEN_H_ diff --git a/sw/device/lib/dif/autogen/dif_usbdev_autogen_unittest.cc b/sw/device/lib/dif/autogen/dif_usbdev_autogen_unittest.cc deleted file mode 100644 index 4bc52da4e571b..0000000000000 --- a/sw/device/lib/dif/autogen/dif_usbdev_autogen_unittest.cc +++ /dev/null @@ -1,390 +0,0 @@ -// 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/make_new_dif.py --mode=regen --only=autogen - -#include "sw/device/lib/dif/autogen/dif_usbdev_autogen.h" - -#include "gtest/gtest.h" -#include "sw/device/lib/base/mmio.h" -#include "sw/device/lib/base/mock_mmio.h" -#include "sw/device/lib/dif/dif_test_base.h" - -#include "usbdev_regs.h" // Generated. - -namespace dif_usbdev_autogen_unittest { -namespace { -using ::mock_mmio::MmioTest; -using ::mock_mmio::MockDevice; -using ::testing::Eq; -using ::testing::Test; - -class UsbdevTest : public Test, public MmioTest { - protected: - dif_usbdev_t usbdev_ = {.base_addr = dev().region()}; -}; - -class InitTest : public UsbdevTest {}; - -TEST_F(InitTest, NullArgs) { - EXPECT_DIF_BADARG(dif_usbdev_init(dev().region(), nullptr)); -} - -TEST_F(InitTest, Success) { - EXPECT_DIF_OK(dif_usbdev_init(dev().region(), &usbdev_)); -} - -class AlertForceTest : public UsbdevTest {}; - -TEST_F(AlertForceTest, NullArgs) { - EXPECT_DIF_BADARG(dif_usbdev_alert_force(nullptr, kDifUsbdevAlertFatalFault)); -} - -TEST_F(AlertForceTest, BadAlert) { - EXPECT_DIF_BADARG( - dif_usbdev_alert_force(nullptr, static_cast(32))); -} - -TEST_F(AlertForceTest, Success) { - // Force first alert. - EXPECT_WRITE32(USBDEV_ALERT_TEST_REG_OFFSET, - {{USBDEV_ALERT_TEST_FATAL_FAULT_BIT, true}}); - EXPECT_DIF_OK(dif_usbdev_alert_force(&usbdev_, kDifUsbdevAlertFatalFault)); -} - -class IrqGetTypeTest : public UsbdevTest {}; - -TEST_F(IrqGetTypeTest, NullArgs) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG( - dif_usbdev_irq_get_type(nullptr, kDifUsbdevIrqPktReceived, &type)); - - EXPECT_DIF_BADARG( - dif_usbdev_irq_get_type(&usbdev_, kDifUsbdevIrqPktReceived, nullptr)); - - EXPECT_DIF_BADARG( - dif_usbdev_irq_get_type(nullptr, kDifUsbdevIrqPktReceived, nullptr)); -} - -TEST_F(IrqGetTypeTest, BadIrq) { - dif_irq_type_t type; - - EXPECT_DIF_BADARG(dif_usbdev_irq_get_type( - &usbdev_, static_cast(kDifUsbdevIrqAvSetupEmpty + 1), - &type)); -} - -TEST_F(IrqGetTypeTest, Success) { - dif_irq_type_t type; - - EXPECT_DIF_OK( - dif_usbdev_irq_get_type(&usbdev_, kDifUsbdevIrqPktReceived, &type)); - EXPECT_EQ(type, kDifIrqTypeStatus); -} - -class IrqGetStateTest : public UsbdevTest {}; - -TEST_F(IrqGetStateTest, NullArgs) { - dif_usbdev_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_usbdev_irq_get_state(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_usbdev_irq_get_state(&usbdev_, nullptr)); - - EXPECT_DIF_BADARG(dif_usbdev_irq_get_state(nullptr, nullptr)); -} - -TEST_F(IrqGetStateTest, SuccessAllRaised) { - dif_usbdev_irq_state_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(USBDEV_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_usbdev_irq_get_state(&usbdev_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -TEST_F(IrqGetStateTest, 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 IrqIsPendingTest : public UsbdevTest {}; - -TEST_F(IrqIsPendingTest, NullArgs) { - bool is_pending; - - EXPECT_DIF_BADARG(dif_usbdev_irq_is_pending(nullptr, kDifUsbdevIrqPktReceived, - &is_pending)); - - EXPECT_DIF_BADARG( - dif_usbdev_irq_is_pending(&usbdev_, kDifUsbdevIrqPktReceived, nullptr)); - - EXPECT_DIF_BADARG( - dif_usbdev_irq_is_pending(nullptr, kDifUsbdevIrqPktReceived, nullptr)); -} - -TEST_F(IrqIsPendingTest, BadIrq) { - bool is_pending; - // All interrupt CSRs are 32 bit so interrupt 32 will be invalid. - EXPECT_DIF_BADARG(dif_usbdev_irq_is_pending( - &usbdev_, static_cast(32), &is_pending)); -} - -TEST_F(IrqIsPendingTest, Success) { - bool irq_state; - - // Get the first IRQ state. - irq_state = false; - EXPECT_READ32(USBDEV_INTR_STATE_REG_OFFSET, - {{USBDEV_INTR_STATE_PKT_RECEIVED_BIT, true}}); - EXPECT_DIF_OK(dif_usbdev_irq_is_pending(&usbdev_, kDifUsbdevIrqPktReceived, - &irq_state)); - EXPECT_TRUE(irq_state); - - // Get the last IRQ state. - irq_state = true; - EXPECT_READ32(USBDEV_INTR_STATE_REG_OFFSET, - {{USBDEV_INTR_STATE_AV_SETUP_EMPTY_BIT, false}}); - EXPECT_DIF_OK(dif_usbdev_irq_is_pending(&usbdev_, kDifUsbdevIrqAvSetupEmpty, - &irq_state)); - 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) { - constexpr uint32_t num_irqs = 18; - constexpr uint32_t irq_mask = (uint64_t{1} << 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) { - EXPECT_DIF_BADARG(dif_usbdev_irq_acknowledge_all(nullptr)); -} - -TEST_F(AcknowledgeAllTest, Success) { - EXPECT_WRITE32(USBDEV_INTR_STATE_REG_OFFSET, - std::numeric_limits::max()); - - EXPECT_DIF_OK(dif_usbdev_irq_acknowledge_all(&usbdev_)); -} - -class IrqAcknowledgeTest : public UsbdevTest {}; - -TEST_F(IrqAcknowledgeTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_usbdev_irq_acknowledge(nullptr, kDifUsbdevIrqPktReceived)); -} - -TEST_F(IrqAcknowledgeTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_usbdev_irq_acknowledge(nullptr, static_cast(32))); -} - -TEST_F(IrqAcknowledgeTest, Success) { - // Clear the first IRQ state. - EXPECT_WRITE32(USBDEV_INTR_STATE_REG_OFFSET, - {{USBDEV_INTR_STATE_PKT_RECEIVED_BIT, true}}); - EXPECT_DIF_OK(dif_usbdev_irq_acknowledge(&usbdev_, kDifUsbdevIrqPktReceived)); - - // Clear the last IRQ state. - EXPECT_WRITE32(USBDEV_INTR_STATE_REG_OFFSET, - {{USBDEV_INTR_STATE_AV_SETUP_EMPTY_BIT, true}}); - EXPECT_DIF_OK( - dif_usbdev_irq_acknowledge(&usbdev_, kDifUsbdevIrqAvSetupEmpty)); -} - -class IrqForceTest : public UsbdevTest {}; - -TEST_F(IrqForceTest, NullArgs) { - EXPECT_DIF_BADARG( - dif_usbdev_irq_force(nullptr, kDifUsbdevIrqPktReceived, true)); -} - -TEST_F(IrqForceTest, BadIrq) { - EXPECT_DIF_BADARG( - dif_usbdev_irq_force(nullptr, static_cast(32), true)); -} - -TEST_F(IrqForceTest, Success) { - // Force first IRQ. - EXPECT_WRITE32(USBDEV_INTR_TEST_REG_OFFSET, - {{USBDEV_INTR_TEST_PKT_RECEIVED_BIT, true}}); - EXPECT_DIF_OK(dif_usbdev_irq_force(&usbdev_, kDifUsbdevIrqPktReceived, true)); - - // Force last IRQ. - EXPECT_WRITE32(USBDEV_INTR_TEST_REG_OFFSET, - {{USBDEV_INTR_TEST_AV_SETUP_EMPTY_BIT, true}}); - EXPECT_DIF_OK( - dif_usbdev_irq_force(&usbdev_, kDifUsbdevIrqAvSetupEmpty, true)); -} - -class IrqGetEnabledTest : public UsbdevTest {}; - -TEST_F(IrqGetEnabledTest, NullArgs) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_usbdev_irq_get_enabled( - nullptr, kDifUsbdevIrqPktReceived, &irq_state)); - - EXPECT_DIF_BADARG( - dif_usbdev_irq_get_enabled(&usbdev_, kDifUsbdevIrqPktReceived, nullptr)); - - EXPECT_DIF_BADARG( - dif_usbdev_irq_get_enabled(nullptr, kDifUsbdevIrqPktReceived, nullptr)); -} - -TEST_F(IrqGetEnabledTest, BadIrq) { - dif_toggle_t irq_state; - - EXPECT_DIF_BADARG(dif_usbdev_irq_get_enabled( - &usbdev_, static_cast(32), &irq_state)); -} - -TEST_F(IrqGetEnabledTest, Success) { - dif_toggle_t irq_state; - - // First IRQ is enabled. - irq_state = kDifToggleDisabled; - EXPECT_READ32(USBDEV_INTR_ENABLE_REG_OFFSET, - {{USBDEV_INTR_ENABLE_PKT_RECEIVED_BIT, true}}); - EXPECT_DIF_OK(dif_usbdev_irq_get_enabled(&usbdev_, kDifUsbdevIrqPktReceived, - &irq_state)); - EXPECT_EQ(irq_state, kDifToggleEnabled); - - // Last IRQ is disabled. - irq_state = kDifToggleEnabled; - EXPECT_READ32(USBDEV_INTR_ENABLE_REG_OFFSET, - {{USBDEV_INTR_ENABLE_AV_SETUP_EMPTY_BIT, false}}); - EXPECT_DIF_OK(dif_usbdev_irq_get_enabled(&usbdev_, kDifUsbdevIrqAvSetupEmpty, - &irq_state)); - EXPECT_EQ(irq_state, kDifToggleDisabled); -} - -class IrqSetEnabledTest : public UsbdevTest {}; - -TEST_F(IrqSetEnabledTest, NullArgs) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG( - dif_usbdev_irq_set_enabled(nullptr, kDifUsbdevIrqPktReceived, irq_state)); -} - -TEST_F(IrqSetEnabledTest, BadIrq) { - dif_toggle_t irq_state = kDifToggleEnabled; - - EXPECT_DIF_BADARG(dif_usbdev_irq_set_enabled( - &usbdev_, static_cast(32), irq_state)); -} - -TEST_F(IrqSetEnabledTest, Success) { - dif_toggle_t irq_state; - - // Enable first IRQ. - irq_state = kDifToggleEnabled; - EXPECT_MASK32(USBDEV_INTR_ENABLE_REG_OFFSET, - {{USBDEV_INTR_ENABLE_PKT_RECEIVED_BIT, 0x1, true}}); - EXPECT_DIF_OK(dif_usbdev_irq_set_enabled(&usbdev_, kDifUsbdevIrqPktReceived, - irq_state)); - - // Disable last IRQ. - irq_state = kDifToggleDisabled; - EXPECT_MASK32(USBDEV_INTR_ENABLE_REG_OFFSET, - {{USBDEV_INTR_ENABLE_AV_SETUP_EMPTY_BIT, 0x1, false}}); - EXPECT_DIF_OK(dif_usbdev_irq_set_enabled(&usbdev_, kDifUsbdevIrqAvSetupEmpty, - irq_state)); -} - -class IrqDisableAllTest : public UsbdevTest {}; - -TEST_F(IrqDisableAllTest, NullArgs) { - dif_usbdev_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_usbdev_irq_disable_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_usbdev_irq_disable_all(nullptr, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessNoSnapshot) { - EXPECT_WRITE32(USBDEV_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_usbdev_irq_disable_all(&usbdev_, nullptr)); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllDisabled) { - dif_usbdev_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(USBDEV_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_WRITE32(USBDEV_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_usbdev_irq_disable_all(&usbdev_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, 0); -} - -TEST_F(IrqDisableAllTest, SuccessSnapshotAllEnabled) { - dif_usbdev_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_READ32(USBDEV_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_WRITE32(USBDEV_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_usbdev_irq_disable_all(&usbdev_, &irq_snapshot)); - EXPECT_EQ(irq_snapshot, std::numeric_limits::max()); -} - -class IrqRestoreAllTest : public UsbdevTest {}; - -TEST_F(IrqRestoreAllTest, NullArgs) { - dif_usbdev_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_DIF_BADARG(dif_usbdev_irq_restore_all(nullptr, &irq_snapshot)); - - EXPECT_DIF_BADARG(dif_usbdev_irq_restore_all(&usbdev_, nullptr)); - - EXPECT_DIF_BADARG(dif_usbdev_irq_restore_all(nullptr, nullptr)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllEnabled) { - dif_usbdev_irq_enable_snapshot_t irq_snapshot = - std::numeric_limits::max(); - - EXPECT_WRITE32(USBDEV_INTR_ENABLE_REG_OFFSET, - std::numeric_limits::max()); - EXPECT_DIF_OK(dif_usbdev_irq_restore_all(&usbdev_, &irq_snapshot)); -} - -TEST_F(IrqRestoreAllTest, SuccessAllDisabled) { - dif_usbdev_irq_enable_snapshot_t irq_snapshot = 0; - - EXPECT_WRITE32(USBDEV_INTR_ENABLE_REG_OFFSET, 0); - EXPECT_DIF_OK(dif_usbdev_irq_restore_all(&usbdev_, &irq_snapshot)); -} - -} // namespace -} // namespace dif_usbdev_autogen_unittest