dl_aesadv.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/*!****************************************************************************
 *  @file       dl_aesadv.h
 *  @brief      Advanced Encryption Standard Advanced (AESADV) Driver Library
 *  @defgroup   AESADV Advanced Encryption Standard Advanced (AESADV)
 *
 *  @anchor ti_dl_dl_aesadv_Overview
 *  # Overview
 *
 *  The AESADV DriverLib allows full configuration of the MSPM0 AESADV module.
 *  The AESADV accelerator module accelerates encryption and decryption
 *  operations in hardware based on the FIPS PUB 197 advanced encryption
 *  standard (AES).
 *
 *  <hr>
 ******************************************************************************/
#ifndef ti_dl_dl_aesadv__include
#define ti_dl_dl_aesadv__include

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

#include <ti/devices/msp/msp.h>
#include <ti/driverlib/dl_common.h>

#ifdef __MSPM0_HAS_AESADV__

#ifdef __cplusplus
extern "C" {
#endif

/* clang-format off */

#define DL_AESADV_INTERRUPT_OUTPUT_READY                                       \
                                       (AESADV_CPU_INT_IMASK_OUTPUTRDY_SET)

#define DL_AESADV_INTERRUPT_INPUT_READY                                        \
                                        (AESADV_CPU_INT_IMASK_INPUTRDY_SET)

#define DL_AESADV_INTERRUPT_SAVED_OUTPUT_CONTEXT_READY                         \
                                   (AESADV_CPU_INT_IMASK_SAVEDCNTXTRDY_SET)

#define DL_AESADV_INTERRUPT_INPUT_CONTEXT_READY                                \
                                        (AESADV_CPU_INT_IMASK_CNTXTRDY_SET)

#define DL_AESADV_EVENT_DMA_DATA_INPUT_TRIGGER                                 \
                                           (AESADV_DMA_TRIG_DATAIN_IMASK_TRIG0_SET)

#define DL_AESADV_EVENT_DMA_DATA_OUTPUT_TRIGGER                                \
                                           (AESADV_DMA_TRIG_DATAOUT_IMASK_TRIG1_SET)

#define DL_AESADV_MODE_MASK                        ((AESADV_CTRL_CBC_MASK) | \
                (AESADV_CTRL_CTR_MASK)     |      (AESADV_CTRL_ICM_MASK) | \
                (AESADV_CTRL_CFB_MASK)     |   (AESADV_CTRL_CBCMAC_MASK) | \
                (AESADV_CTRL_GCM_MASK)     |      (AESADV_CTRL_CCM_MASK) | \
                (AESADV_CTRL_OFB_GCM_CCM_CONT_MASK) | 0x02000000)

/* TODO: create define once XCBC-MAC MASK defined in IPXACT */

/* clang-format on */

typedef enum {
    DL_AESADV_IIDX_INPUT_CONTEXT_READY = AESADV_CPU_INT_IIDX_STAT_CNTXTRDY,
    DL_AESADV_IIDX_SAVED_OUTPUT_CONTEXT_READY =
        AESADV_CPU_INT_IIDX_STAT_SAVEDCNTXTRDY,
    DL_AESADV_IIDX_INPUT_READY = AESADV_CPU_INT_IIDX_STAT_INPUTRDY,
    DL_AESADV_IIDX_OUTPUT_READY = AESADV_CPU_INT_IIDX_STAT_OUTPUTRDY,
    DL_AESADV_IIDX_DMA_INPUT_TRIGGER = AESADV_DMA_TRIG_DATAIN_IIDX_STAT_TRIG0,
    DL_AESADV_IIDX_DMA_OUTPUT_TRIGGER =
        AESADV_DMA_TRIG_DATAOUT_IIDX_STAT_TRIG1,
} DL_AESADV_IIDX;

typedef enum {
    DL_AESADV_MODE_ECB = 0x00,
    DL_AESADV_MODE_CBC = (AESADV_CTRL_CBC_ENABLE),
    DL_AESADV_MODE_CTR = (AESADV_CTRL_CTR_ENABLE),
    DL_AESADV_MODE_ICM = (AESADV_CTRL_ICM_ENABLE),
    DL_AESADV_MODE_CFB = (AESADV_CTRL_CFB_ENABLE),
    DL_AESADV_MODE_OFB = (AESADV_CTRL_OFB_GCM_CCM_CONT_OFB),
    DL_AESADV_MODE_CMAC =
        (0x02000000 |
            AESADV_CTRL_CBC_ENABLE), /* TODO: add CMAC-define when given */
    DL_AESADV_MODE_CBCMAC = (AESADV_CTRL_CBCMAC_ENABLE),
    /* TODO: Update GCM values once new defines in place */
    DL_AESADV_MODE_GCM_FORCE_ZERO =
        (AESADV_CTRL_GCM_FORCE_ZERO) | (AESADV_CTRL_CTR_ENABLE),
    DL_AESADV_MODE_GCM_LOAD_HASH_KEY =
        (AESADV_CTRL_GCM_LOAD_HASH_KEY) | (AESADV_CTRL_CTR_ENABLE),
    DL_AESADV_MODE_GCM_AUTONOMOUS =
        (AESADV_CTRL_GCM_AUTONOMOUS) | (AESADV_CTRL_CTR_ENABLE),
    DL_AESADV_MODE_GCM_GHASH_ONLY = (AESADV_CTRL_GCM_FORCE_ZERO),
    DL_AESADV_MODE_CCM = (AESADV_CTRL_CCM_ENABLE) | (AESADV_CTRL_CTR_ENABLE),
} DL_AESADV_MODE;

typedef enum {
    DL_AESADV_KEY_SIZE_128_BIT = AESADV_CTRL_KEYSIZE_K128,
    DL_AESADV_KEY_SIZE_256_BIT = AESADV_CTRL_KEYSIZE_K256,
} DL_AESADV_KEY_SIZE;

typedef enum {
    DL_AESADV_DIR_ENCRYPT = AESADV_CTRL_DIR_ENCRYPT,
    DL_AESADV_DIR_DECRYPT = AESADV_CTRL_DIR_DECRYPT,
} DL_AESADV_DIR;

typedef enum {
    DL_AESADV_CTR_WIDTH_32_BIT = AESADV_CTRL_CTR_WIDTH_CTR32,
    DL_AESADV_CTR_WIDTH_64_BIT = AESADV_CTRL_CTR_WIDTH_CTR64,
    DL_AESADV_CTR_WIDTH_96_BIT = AESADV_CTRL_CTR_WIDTH_CTR96,
    DL_AESADV_CTR_WIDTH_128_BIT = AESADV_CTRL_CTR_WIDTH_CTR128,
} DL_AESADV_CTR_WIDTH;

typedef enum {
    DL_AESADV_FB_WIDTH_128 = AESADV_CTRL_CTR_WIDTH_CFB128,
} DL_AESADV_FB_WIDTH;

typedef enum {
    DL_AESADV_CCM_CTR_WIDTH_2_BYTES = ((uint32_t) 1U << AESADV_CTRL_CCML_OFS),
    DL_AESADV_CCM_CTR_WIDTH_3_BYTES = ((uint32_t) 2 << AESADV_CTRL_CCML_OFS),
    DL_AESADV_CCM_CTR_WIDTH_4_BYTES = ((uint32_t) 3 << AESADV_CTRL_CCML_OFS),
    DL_AESADV_CCM_CTR_WIDTH_5_BYTES = ((uint32_t) 4 << AESADV_CTRL_CCML_OFS),
    DL_AESADV_CCM_CTR_WIDTH_6_BYTES = ((uint32_t) 5 << AESADV_CTRL_CCML_OFS),
    DL_AESADV_CCM_CTR_WIDTH_7_BYTES = ((uint32_t) 6 << AESADV_CTRL_CCML_OFS),
    DL_AESADV_CCM_CTR_WIDTH_8_BYTES = ((uint32_t) 7 << AESADV_CTRL_CCML_OFS),
} DL_AESADV_CCM_CTR_WIDTH;

typedef enum {
    DL_AESADV_CCM_TAG_WIDTH_1_BYTE = ((uint32_t) 0 << AESADV_CTRL_CCMM_OFS),
    DL_AESADV_CCM_TAG_WIDTH_2_BYTES = ((uint32_t) 1 << AESADV_CTRL_CCMM_OFS),
    DL_AESADV_CCM_TAG_WIDTH_3_BYTES = ((uint32_t) 2 << AESADV_CTRL_CCMM_OFS),
    DL_AESADV_CCM_TAG_WIDTH_4_BYTES = ((uint32_t) 3 << AESADV_CTRL_CCMM_OFS),
    DL_AESADV_CCM_TAG_WIDTH_5_BYTES = ((uint32_t) 4 << AESADV_CTRL_CCMM_OFS),
    DL_AESADV_CCM_TAG_WIDTH_6_BYTES = ((uint32_t) 5 << AESADV_CTRL_CCMM_OFS),
    DL_AESADV_CCM_TAG_WIDTH_7_BYTES = ((uint32_t) 6 << AESADV_CTRL_CCMM_OFS),
    DL_AESADV_CCM_TAG_WIDTH_8_BYTES = ((uint32_t) 7 << AESADV_CTRL_CCMM_OFS),
} DL_AESADV_CCM_TAG_WIDTH;

typedef enum {
    DL_AESADV_STATUS_SUCCESS,
    DL_AESADV_STATUS_UNALIGNED_ACCESS,
} DL_AESADV_STATUS;

typedef struct {
    DL_AESADV_MODE mode;
    DL_AESADV_DIR direction;
    DL_AESADV_CTR_WIDTH ctr_ctrWidth;
    DL_AESADV_FB_WIDTH cfb_fbWidth;
    DL_AESADV_CCM_CTR_WIDTH ccm_ctrWidth;
    DL_AESADV_CCM_TAG_WIDTH ccm_tagWidth;
    uint8_t *iv;
    uint8_t *nonce;
    uint8_t *k1;
    uint8_t *k2;
    uint32_t lowerCryptoLength;
    uint32_t upperCryptoLength;
    uint32_t aadLength;
} DL_AESADV_Config;

__STATIC_INLINE void DL_AESADV_enablePower(AESADV_Regs *aesadv)
{
    aesadv->GPRCM.PWREN =
        (AESADV_PWREN_KEY_UNLOCK_W | AESADV_PWREN_ENABLE_ENABLE);
}

__STATIC_INLINE void DL_AESADV_disablePower(AESADV_Regs *aesadv)
{
    aesadv->GPRCM.PWREN =
        (AESADV_PWREN_KEY_UNLOCK_W | AESADV_PWREN_ENABLE_DISABLE);
}

__STATIC_INLINE bool DL_AESADV_isPowerEnabled(const AESADV_Regs *aesadv)
{
    return ((aesadv->GPRCM.PWREN & AESADV_PWREN_ENABLE_MASK) ==
            AESADV_PWREN_ENABLE_ENABLE);
}

__STATIC_INLINE void DL_AESADV_reset(AESADV_Regs *aesadv)
{
    aesadv->GPRCM.RSTCTL =
        (AESADV_RSTCTL_KEY_UNLOCK_W | AESADV_RSTCTL_RESETSTKYCLR_CLR |
            AESADV_RSTCTL_RESETASSERT_ASSERT);
}

__STATIC_INLINE bool DL_AESADV_isReset(const AESADV_Regs *aesadv)
{
    return ((aesadv->GPRCM.STAT & AESADV_STAT_RESETSTKY_MASK) ==
            AESADV_STAT_RESETSTKY_RESET);
}

__STATIC_INLINE bool DL_AESADV_isOutputReady(const AESADV_Regs *aesadv)
{
    return ((aesadv->CTRL & AESADV_CTRL_OUTPUT_RDY_MASK) ==
            AESADV_CTRL_OUTPUT_RDY_READY);
}

__STATIC_INLINE bool DL_AESADV_isInputReady(const AESADV_Regs *aesadv)
{
    return ((aesadv->CTRL & AESADV_CTRL_INPUT_RDY_MASK) ==
            AESADV_CTRL_INPUT_RDY_EMPTY);
}

__STATIC_INLINE void DL_AESADV_setDirection(
    AESADV_Regs *aesadv, DL_AESADV_DIR direction)
{
    DL_Common_updateReg(
        &aesadv->CTRL, (uint32_t) direction, AESADV_CTRL_DIR_MASK);
}

__STATIC_INLINE DL_AESADV_DIR DL_AESADV_getDirection(const AESADV_Regs *aesadv)
{
    uint32_t direction = (aesadv->CTRL & AESADV_CTRL_DIR_MASK);

    return (DL_AESADV_DIR)(direction);
}

__STATIC_INLINE void DL_AESADV_setKeySize(
    AESADV_Regs *aesadv, DL_AESADV_KEY_SIZE size)
{
    DL_Common_updateReg(
        &aesadv->CTRL, (uint32_t) size, AESADV_CTRL_KEYSIZE_MASK);
}

__STATIC_INLINE DL_AESADV_KEY_SIZE DL_AESADV_getKeySize(
    const AESADV_Regs *aesadv)
{
    uint32_t keySize = (aesadv->CTRL & AESADV_CTRL_KEYSIZE_MASK);

    return (DL_AESADV_KEY_SIZE)(keySize);
}

__STATIC_INLINE void DL_AESADV_setMode(
    AESADV_Regs *aesadv, DL_AESADV_MODE mode)
{
    DL_Common_updateReg(&aesadv->CTRL, (uint32_t) mode, DL_AESADV_MODE_MASK);
}

__STATIC_INLINE DL_AESADV_MODE DL_AESADV_getMode(const AESADV_Regs *aesadv)
{
    uint32_t mode = (aesadv->CTRL & DL_AESADV_MODE_MASK);
    return (DL_AESADV_MODE)(mode);
}

__STATIC_INLINE void DL_AESADV_setFeedbackWidth(
    AESADV_Regs *aesadv, DL_AESADV_FB_WIDTH fbWidth)
{
    DL_Common_updateReg(
        &aesadv->CTRL, (uint32_t) fbWidth, AESADV_CTRL_CTR_WIDTH_MASK);
}

__STATIC_INLINE DL_AESADV_FB_WIDTH DL_AESADV_getFeedbackWidth(
    const AESADV_Regs *aesadv)
{
    uint32_t fbWidth = (aesadv->CTRL & AESADV_CTRL_CTR_WIDTH_MASK);

    return (DL_AESADV_FB_WIDTH)(fbWidth);
}

__STATIC_INLINE void DL_AESADV_setCounterWidth(
    AESADV_Regs *aesadv, DL_AESADV_CTR_WIDTH ctrWidth)
{
    DL_Common_updateReg(
        &aesadv->CTRL, (uint32_t) ctrWidth, AESADV_CTRL_CTR_WIDTH_MASK);
}

__STATIC_INLINE DL_AESADV_CTR_WIDTH DL_AESADV_getCounterWidth(
    const AESADV_Regs *aesadv)
{
    uint32_t ctrWidth = (aesadv->CTRL & AESADV_CTRL_CTR_WIDTH_MASK);

    return (DL_AESADV_CTR_WIDTH)(ctrWidth);
}

__STATIC_INLINE void DL_AESADV_setCCMCounterWidth(
    AESADV_Regs *aesadv, DL_AESADV_CCM_CTR_WIDTH ccm_ctrWidth)
{
    DL_Common_updateReg(
        &aesadv->CTRL, (uint32_t) ccm_ctrWidth, AESADV_CTRL_CCML_MASK);
}

__STATIC_INLINE DL_AESADV_CCM_CTR_WIDTH DL_AESADV_getCCMCounterWidth(
    const AESADV_Regs *aesadv)
{
    uint32_t ccm_ctrWidth = (aesadv->CTRL & AESADV_CTRL_CCML_MASK);

    return (DL_AESADV_CCM_CTR_WIDTH)(ccm_ctrWidth);
}

__STATIC_INLINE void DL_AESADV_setCCMTagWidth(
    AESADV_Regs *aesadv, DL_AESADV_CCM_TAG_WIDTH ccm_tagWidth)
{
    DL_Common_updateReg(
        &aesadv->CTRL, (uint32_t) ccm_tagWidth, AESADV_CTRL_CCMM_MASK);
}

__STATIC_INLINE DL_AESADV_CCM_TAG_WIDTH DL_AESADV_getCCMTagWidth(
    const AESADV_Regs *aesadv)
{
    uint32_t ccm_tagWidth = (aesadv->CTRL & AESADV_CTRL_CCMM_MASK);

    return (DL_AESADV_CCM_TAG_WIDTH)(ccm_tagWidth);
}

__STATIC_INLINE void DL_AESADV_haltOperationAndGenerateDigest(
    AESADV_Regs *aesadv)
{
    aesadv->CTRL |= AESADV_CTRL_GET_DIGEST_ENABLE;
}

__STATIC_INLINE void DL_AESADV_resumeAADPhase(
    AESADV_Regs *aesadv, DL_AESADV_MODE mode)
{
    DL_Common_updateReg(&aesadv->CTRL,
        (((uint32_t) mode) |
            ((uint32_t) AESADV_CTRL_OFB_GCM_CCM_CONT_GCM_CCM_CONTINUE)),
        (DL_AESADV_MODE_MASK | AESADV_CTRL_OFB_GCM_CCM_CONT_MASK));
}

__STATIC_INLINE void DL_AESADV_resumeDataPhase(
    AESADV_Regs *aesadv, DL_AESADV_MODE mode)
{
    DL_Common_updateReg(&aesadv->CTRL,
        ((uint32_t) mode | AESADV_CTRL_GCM_CONT_ENABLE),
        ((uint32_t) DL_AESADV_MODE_MASK | AESADV_CTRL_GCM_CONT_MASK));
}

__STATIC_INLINE void DL_AESADV_enableSavedOutputContext(AESADV_Regs *aesadv)
{
    aesadv->CTRL |= AESADV_CTRL_SAVE_CNTXT_ENABLE;
}

__STATIC_INLINE void DL_AESADV_disableSavedOutputContext(AESADV_Regs *aesadv)
{
    aesadv->CTRL &= ~(AESADV_CTRL_SAVE_CNTXT_ENABLE);
}

__STATIC_INLINE bool DL_AESADV_isSavedOutputContextEnabled(
    const AESADV_Regs *aesadv)
{
    return ((aesadv->CTRL & AESADV_CTRL_SAVE_CNTXT_MASK) ==
            AESADV_CTRL_SAVE_CNTXT_ENABLE);
}

__STATIC_INLINE bool DL_AESADV_isSavedOutputContextReady(
    const AESADV_Regs *aesadv)
{
    return ((aesadv->CTRL & AESADV_CTRL_SAVED_CNTXT_RDY_MASK) ==
            AESADV_CTRL_SAVED_CNTXT_RDY_READY);
}

__STATIC_INLINE bool DL_AESADV_isInputContextWriteable(
    const AESADV_Regs *aesadv)
{
    return ((aesadv->CTRL & AESADV_CTRL_CNTXT_RDY_MASK) ==
            AESADV_CTRL_CNTXT_RDY_READY);
}

__STATIC_INLINE void DL_AESADV_setLowerCryptoLength(
    AESADV_Regs *aesadv, uint32_t lowerLength)
{
    aesadv->C_LENGTH_0 = lowerLength;
}

__STATIC_INLINE void DL_AESADV_setUpperCryptoLength(
    AESADV_Regs *aesadv, uint32_t upperLength)
{
    aesadv->C_LENGTH_1 = upperLength & 0x1FFFFFFFU;
}

__STATIC_INLINE void DL_AESADV_setAADLength(
    AESADV_Regs *aesadv, uint32_t aadLength)
{
    aesadv->AAD_LENGTH = aadLength;
}

__STATIC_INLINE void DL_AESADV_enableDMAOperation(AESADV_Regs *aesadv)
{
    aesadv->DMA_HS = (AESADV_DMA_HS_DMA_DATA_ACK_DMA_ENABLE);
}

__STATIC_INLINE void DL_AESADV_disableDMAOperation(AESADV_Regs *aesadv)
{
    aesadv->DMA_HS = (AESADV_DMA_HS_DMA_DATA_ACK_DMA_DISABLE);
}

__STATIC_INLINE bool DL_AESADV_isDMAOperationEnabled(const AESADV_Regs *aesadv)
{
    return ((aesadv->DMA_HS & AESADV_DMA_HS_DMA_DATA_ACK_MASK) ==
            AESADV_DMA_HS_DMA_DATA_ACK_DMA_ENABLE);
}

__STATIC_INLINE bool DL_AESADV_isUserKeyWriteEnabled(const AESADV_Regs *aesadv)
{
    return ((aesadv->STATUS & AESADV_STATUS_KEYWR_MASK) ==
            AESADV_STATUS_KEYWR_ENABLED);
}

DL_AESADV_STATUS DL_AESADV_setKey(
    AESADV_Regs *aesadv, const uint8_t *key, DL_AESADV_KEY_SIZE keySize);

void DL_AESADV_setKeyAligned(AESADV_Regs *aesadv, const uint32_t *keyAligned,
    DL_AESADV_KEY_SIZE keySize);

DL_AESADV_STATUS DL_AESADV_setGCMHashKey(
    AESADV_Regs *aesadv, const uint8_t *hashKey);

void DL_AESADV_setGCMHashKeyAligned(
    AESADV_Regs *aesadv, const uint32_t *hashKeyAligned);

DL_AESADV_STATUS DL_AESADV_setSecondKey(
    AESADV_Regs *aesadv, const uint8_t *secondKey);

void DL_AESADV_setSecondKeyAligned(
    AESADV_Regs *aesadv, const uint32_t *secondKeyAligned);

DL_AESADV_STATUS DL_AESADV_setThirdKey(
    AESADV_Regs *aesadv, const uint8_t *thirdKey);

void DL_AESADV_setThirdKeyAligned(
    AESADV_Regs *aesadv, const uint32_t *thirdKeyAligned);

DL_AESADV_STATUS DL_AESADV_loadIntermediateTAG(
    AESADV_Regs *aesadv, const uint8_t *tag);

void DL_AESADV_loadIntermediateTAGAligned(
    AESADV_Regs *aesadv, const uint32_t *tagAligned);

DL_AESADV_STATUS DL_AESADV_loadInitializationVector(
    AESADV_Regs *aesadv, const uint8_t *iv);

void DL_AESADV_loadInitializationVectorAligned(
    AESADV_Regs *aesadv, const uint32_t *ivAligned);

DL_AESADV_STATUS DL_AESADV_readInitializationVector(
    AESADV_Regs *aesadv, const uint8_t *iv);

void DL_AESADV_readInitializationVectorAligned(
    AESADV_Regs *aesadv, uint32_t *ivAligned);

void DL_AESADV_loadCCMNonceAndCounter(
    AESADV_Regs *aesadv, uint8_t *nonce, DL_AESADV_CCM_CTR_WIDTH ctrWidth);

DL_AESADV_STATUS DL_AESADV_loadInputData(
    AESADV_Regs *aesadv, const uint8_t *data);

void DL_AESADV_loadInputDataAligned(
    AESADV_Regs *aesadv, const uint32_t *dataAligned);

DL_AESADV_STATUS DL_AESADV_readOutputData(
    const AESADV_Regs *aesadv, const uint8_t *data);

void DL_AESADV_readOutputDataAligned(
    const AESADV_Regs *aesadv, uint32_t *dataAligned);

DL_AESADV_STATUS DL_AESADV_readTAG(
    const AESADV_Regs *aesadv, const uint8_t *tag);

void DL_AESADV_readTAGAligned(const AESADV_Regs *aesadv, uint32_t *tagAligned);

__STATIC_INLINE void DL_AESADV_forceInputDataAvailable(AESADV_Regs *aesadv)
{
    aesadv->FORCE_IN_AV = 0x0123CAFE;
}

__STATIC_INLINE void DL_AESADV_setCCMAlignWord(
    AESADV_Regs *aesadv, uint32_t alignWord)
{
    aesadv->CCM_ALN_WRD = alignWord;
}

__STATIC_INLINE uint32_t DL_AESADV_getCCMAlignWord(const AESADV_Regs *aesadv)
{
    return (aesadv->CCM_ALN_WRD);
}

__STATIC_INLINE void DL_AESADV_setLowerBlockCount(
    AESADV_Regs *aesadv, uint32_t lowerBlockCount)
{
    aesadv->BLK_CNT0 = lowerBlockCount;
}

__STATIC_INLINE uint32_t DL_AESADV_getLowerBlockCount(
    const AESADV_Regs *aesadv)
{
    return aesadv->BLK_CNT0;
}

__STATIC_INLINE void DL_AESADV_setUpperBlockCount(
    AESADV_Regs *aesadv, uint32_t upperBlockCount)
{
    aesadv->BLK_CNT1 = (upperBlockCount & 0x01FFFFFFU);
}

__STATIC_INLINE uint32_t DL_AESADV_getUpperBlockCount(
    const AESADV_Regs *aesadv)
{
    return (aesadv->BLK_CNT1 & 0x01FFFFFFU);
}

__STATIC_INLINE void DL_AESADV_enableInterrupt(
    AESADV_Regs *aesadv, uint32_t interruptMask)
{
    aesadv->CPU_INT.IMASK |= interruptMask;
}

__STATIC_INLINE void DL_AESADV_disableInterrupt(
    AESADV_Regs *aesadv, uint32_t interruptMask)
{
    aesadv->CPU_INT.IMASK &= ~(interruptMask);
}

__STATIC_INLINE uint32_t DL_AESADV_getEnabledInterrupts(
    const AESADV_Regs *aesadv, uint32_t interruptMask)
{
    return (aesadv->CPU_INT.IMASK & interruptMask);
}

__STATIC_INLINE uint32_t DL_AESADV_getEnabledInterruptStatus(
    const AESADV_Regs *aesadv, uint32_t interruptMask)
{
    return (aesadv->CPU_INT.MIS & interruptMask);
}

__STATIC_INLINE uint32_t DL_AESADV_getRawInterruptStatus(
    const AESADV_Regs *aesadv, uint32_t interruptMask)
{
    return (aesadv->CPU_INT.RIS & interruptMask);
}

__STATIC_INLINE DL_AESADV_IIDX DL_AESADV_getPendingInterrupt(
    const AESADV_Regs *aesadv)
{
    return ((DL_AESADV_IIDX) aesadv->CPU_INT.IIDX);
}

__STATIC_INLINE void DL_AESADV_clearInterruptStatus(
    AESADV_Regs *aesadv, uint32_t interruptMask)
{
    aesadv->CPU_INT.ICLR = interruptMask;
}

__STATIC_INLINE void DL_AESADV_enableDMAInputTriggerEvent(AESADV_Regs *aesadv)
{
    aesadv->DMA_TRIG_DATAIN.IMASK |= DL_AESADV_EVENT_DMA_DATA_INPUT_TRIGGER;
}

__STATIC_INLINE void DL_AESADV_enableDMAOutputTriggerEvent(AESADV_Regs *aesadv)
{
    aesadv->DMA_TRIG_DATAOUT.IMASK |= DL_AESADV_EVENT_DMA_DATA_OUTPUT_TRIGGER;
}

__STATIC_INLINE void DL_AESADV_disableDMAInputTriggerEvent(AESADV_Regs *aesadv)
{
    aesadv->DMA_TRIG_DATAIN.IMASK &= ~(DL_AESADV_EVENT_DMA_DATA_INPUT_TRIGGER);
}

__STATIC_INLINE void DL_AESADV_disableDMAOutputTriggerEvent(
    AESADV_Regs *aesadv)
{
    aesadv->DMA_TRIG_DATAOUT.IMASK &=
        ~(DL_AESADV_EVENT_DMA_DATA_OUTPUT_TRIGGER);
}

__STATIC_INLINE uint32_t DL_AESADV_getEnabledDMAInputTriggerEvent(
    const AESADV_Regs *aesadv)
{
    return (aesadv->DMA_TRIG_DATAIN.IMASK &
            DL_AESADV_EVENT_DMA_DATA_INPUT_TRIGGER);
}

__STATIC_INLINE uint32_t DL_AESADV_getEnabledDMAOutputTriggerEvent(
    const AESADV_Regs *aesadv)
{
    return (aesadv->DMA_TRIG_DATAOUT.IMASK &
            DL_AESADV_EVENT_DMA_DATA_OUTPUT_TRIGGER);
}

__STATIC_INLINE uint32_t DL_AESADV_getEnabledDMAInputTriggerEventStatus(
    const AESADV_Regs *aesadv)
{
    return (
        aesadv->DMA_TRIG_DATAIN.MIS & DL_AESADV_EVENT_DMA_DATA_INPUT_TRIGGER);
}

__STATIC_INLINE uint32_t DL_AESADV_getEnabledDMAOutputTriggerEventStatus(
    const AESADV_Regs *aesadv)
{
    return (aesadv->DMA_TRIG_DATAOUT.MIS &
            DL_AESADV_EVENT_DMA_DATA_OUTPUT_TRIGGER);
}

__STATIC_INLINE uint32_t DL_AESADV_getRawDMAInputTriggerEventStatus(
    const AESADV_Regs *aesadv)
{
    return (
        aesadv->DMA_TRIG_DATAIN.RIS & DL_AESADV_EVENT_DMA_DATA_INPUT_TRIGGER);
}

__STATIC_INLINE uint32_t DL_AESADV_getRawDMAOutputTriggerEventStatus(
    const AESADV_Regs *aesadv)
{
    return (aesadv->DMA_TRIG_DATAOUT.RIS &
            DL_AESADV_EVENT_DMA_DATA_OUTPUT_TRIGGER);
}

__STATIC_INLINE DL_AESADV_IIDX DL_AESADV_getPendingDMAInputTriggerEvent(
    const AESADV_Regs *aesadv)
{
    uint32_t eventIIDX = aesadv->DMA_TRIG_DATAIN.IIDX;

    return (DL_AESADV_IIDX) eventIIDX;
}

__STATIC_INLINE DL_AESADV_IIDX DL_AESADV_getPendingDMAOutputTriggerEvent(
    const AESADV_Regs *aesadv)
{
    uint32_t eventIIDX = aesadv->DMA_TRIG_DATAOUT.IIDX;

    return (DL_AESADV_IIDX)(eventIIDX);
}

__STATIC_INLINE void DL_AESADV_clearDMAInputTriggerEventStatus(
    AESADV_Regs *aesadv)
{
    aesadv->DMA_TRIG_DATAIN.ICLR = DL_AESADV_EVENT_DMA_DATA_INPUT_TRIGGER;
}

__STATIC_INLINE void DL_AESADV_clearDMAOutputTriggerEventStatus(
    AESADV_Regs *aesadv)
{
    aesadv->DMA_TRIG_DATAOUT.ICLR = DL_AESADV_EVENT_DMA_DATA_OUTPUT_TRIGGER;
}

__STATIC_INLINE uintptr_t DL_AESADV_getDATAINAddr(const AESADV_Regs *aesadv)
{
    return ((uintptr_t) &aesadv->DATA0);
}

__STATIC_INLINE uintptr_t DL_AESADV_getDATAOUTAddr(const AESADV_Regs *aesadv)
{
    return ((uintptr_t) &aesadv->DATA0);
}

void DL_AESADV_initECB(AESADV_Regs *aesadv, const DL_AESADV_Config *config);

void DL_AESADV_initCBC(AESADV_Regs *aesadv, const DL_AESADV_Config *config);

void DL_AESADV_initCFB(AESADV_Regs *aesadv, const DL_AESADV_Config *config);

void DL_AESADV_initOFB(AESADV_Regs *aesadv, const DL_AESADV_Config *config);

void DL_AESADV_initCTR(AESADV_Regs *aesadv, const DL_AESADV_Config *config);

void DL_AESADV_initICM(AESADV_Regs *aesadv, const DL_AESADV_Config *config);

void DL_AESADV_initCMAC(AESADV_Regs *aesadv, const DL_AESADV_Config *config);

void DL_AESADV_initCBCMAC(AESADV_Regs *aesadv, const DL_AESADV_Config *config);

void DL_AESADV_initGCM(AESADV_Regs *aesadv, const DL_AESADV_Config *config);

void DL_AESADV_initCCM(AESADV_Regs *aesadv, DL_AESADV_Config *config);

#ifdef __cplusplus
}
#endif

#endif /* __MSPM0_HAS_AESADV__ */

#endif /* ti_dl_dl_aesadv__include */