aes.h

Go to the documentation of this file.

/******************************************************************************
 *  Copyright (c) 2022-2023 Texas Instruments Incorporated
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1) Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *
 *  2) 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.
 *
 *  3) Neither the name of the copyright holder 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 HOLDER 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       aes.h
 *
 *  @brief      AES module header for CC23X0R5 devices
 *
 *  @anchor     ti_devices_cc23x0r5_aes_overview
 *
 *  This module provides the low-level functions used to access the LAES128
 *  crypto engine.
 ******************************************************************************/

#ifndef __AES_H__
#define __AES_H__

#include <stdint.h>

#include "../inc/hw_types.h"
#include "../inc/hw_memmap.h"
#include "../inc/hw_aes.h"

#ifdef __cplusplus
extern "C" {
#endif

#define AES_BLOCK_SIZE                          16U 
#define AES_BLOCK_SIZE_WORDS                    (AES_BLOCK_SIZE / 4U)
#define AES_BLOCK_SIZE_MULTIPLE_MASK            0xFFFFFFF0U
#define AES_BLOCK_SIZE_MULTIPLE_LENGTH(len)     ((len)&AES_BLOCK_SIZE_MULTIPLE_MASK)
#define AES_NON_BLOCK_SIZE_MULTIPLE_MASK        0x0000000FU
#define AES_NON_BLOCK_SIZE_MULTIPLE_LENGTH(len) ((len)&AES_NON_BLOCK_SIZE_MULTIPLE_MASK)
#define AES_GET_NUM_BLOCKS(len)                 ((len) >> 4)
#define AES_BLOCKS_TO_BYTES(numBlocks)          ((numBlocks) << 4)

#define AES_DOUBLE_BLOCK_SIZE_MULTIPLE_MASK (size_t)(0xFFFFFFE0UL)

#define AES_IV_LENGTH_BYTES  AES_BLOCK_SIZE
#define AES_TAG_LENGTH_BYTES AES_BLOCK_SIZE

#define AES_128_KEY_LENGTH_BYTES (128U / 8U)

#define IS_WORD_ALIGNED(ptr) (((uintptr_t)(ptr) << 30) == 0U)

#define AES_ICLR_ALL \
    ((uint32_t)AES_ICLR_AESDONE | (uint32_t)AES_ICLR_AESSTART | (uint32_t)AES_ICLR_CHADONE | (uint32_t)AES_ICLR_CHBDONE)

typedef union
{
    uint32_t words[4];
    uint8_t bytes[16];
} AES_BlockWordAligned;

void AESProcessAlignedBlocksCMAC(const uint32_t *input, uint32_t numBlocks);

void AESProcessAlignedBlocksCTR(const uint32_t *input, uint32_t *output, uint32_t numBlocks);

void AESProcessAlignedBlocksECB(const uint32_t *input, uint32_t *output, uint32_t numBlocks);

void AESCopyBlock(void *dst, const void *src);

__STATIC_INLINE void AESWriteKEY(const uint8_t key[16])
{
    AESCopyBlock((void *)(AES_BASE + AES_O_KEY0), key);
}

__STATIC_INLINE void AESWriteBUF(const uint8_t buf[16])
{
    AESCopyBlock((void *)(AES_BASE + AES_O_BUF0), buf);
}

__STATIC_INLINE void AESWriteBUF32(const uint32_t buf[4])
{
    HWREG(AES_BASE + AES_O_BUF0) = buf[0];
    HWREG(AES_BASE + AES_O_BUF1) = buf[1];
    HWREG(AES_BASE + AES_O_BUF2) = buf[2];
    HWREG(AES_BASE + AES_O_BUF3) = buf[3];
}

__STATIC_INLINE void AESReadBUF(uint8_t buf[16])
{
    AESCopyBlock(buf, (const void *)(AES_BASE + AES_O_BUF0));
}

__STATIC_INLINE void AESReadBUF32(uint32_t buf[4])
{
    buf[0] = HWREG(AES_BASE + AES_O_BUF0);
    buf[1] = HWREG(AES_BASE + AES_O_BUF1);
    buf[2] = HWREG(AES_BASE + AES_O_BUF2);
    buf[3] = HWREG(AES_BASE + AES_O_BUF3);
}

__STATIC_INLINE void AESWriteTXTXOR(const uint8_t txtxor[16])
{
    AESCopyBlock((void *)(AES_BASE + AES_O_TXTX0), txtxor);
}

__STATIC_INLINE void AESWriteTXTXOR32(const uint32_t txtxor[4])
{
    HWREG(AES_BASE + AES_O_TXTX0) = txtxor[0];
    HWREG(AES_BASE + AES_O_TXTX1) = txtxor[1];
    HWREG(AES_BASE + AES_O_TXTX2) = txtxor[2];
    HWREG(AES_BASE + AES_O_TXTX3) = txtxor[3];
}

__STATIC_INLINE void AESReadTXTXBUF(uint8_t txtxbuf[16])
{
    AESCopyBlock(txtxbuf, (const void *)(AES_BASE + AES_O_TXTXBUF0));
}

__STATIC_INLINE void AESWriteTXT(const uint8_t txt[16])
{
    AESCopyBlock((void *)(AES_BASE + AES_O_TXT0), txt);
}

__STATIC_INLINE void AESWriteTXT32(const uint32_t txt[4])
{
    HWREG(AES_BASE + AES_O_TXT0) = txt[0];
    HWREG(AES_BASE + AES_O_TXT1) = txt[1];
    HWREG(AES_BASE + AES_O_TXT2) = txt[2];
    HWREG(AES_BASE + AES_O_TXT3) = txt[3];
}

__STATIC_INLINE void AESReadTXT(uint8_t txt[16])
{
    AESCopyBlock(txt, (const void *)(AES_BASE + AES_O_TXT0));
}

__STATIC_INLINE void AESReadTXT32(uint32_t txt[4])
{
    txt[0] = HWREG(AES_BASE + AES_O_TXT0);
    txt[1] = HWREG(AES_BASE + AES_O_TXT1);
    txt[2] = HWREG(AES_BASE + AES_O_TXT2);
    txt[3] = HWREG(AES_BASE + AES_O_TXT3);
}

__STATIC_INLINE void AESWriteTag(const uint8_t tag[16])
{
    AESWriteTXT(tag);
}

__STATIC_INLINE void AESWriteTag32(const uint32_t tag[4])
{
    AESWriteTXT32(tag);
}

__STATIC_INLINE void AESReadTag(uint8_t tag[16])
{
    AESReadTXT(tag);
}

__STATIC_INLINE void AESReadTag32(uint32_t tag[4])
{
    AESReadTXT32(tag);
}

__STATIC_INLINE void AESSetAUTOCFG(uint32_t autoCfg)
{
    HWREG(AES_BASE + AES_O_AUTOCFG) = autoCfg;
}

__STATIC_INLINE void AESClearAUTOCFGTrigger(void)
{
    /* Read the current AUTOCFG value */
    uint32_t autoCfg = HWREG(AES_BASE + AES_O_AUTOCFG);

    /* Clear the TRGECB bits */
    autoCfg &= (uint32_t)~AES_AUTOCFG_TRGAES_M;

    HWREG(AES_BASE + AES_O_AUTOCFG) = autoCfg;
}

__STATIC_INLINE void AESClearAUTOCFGBusHalt(void)
{
    /* Read the current AUTOCFG value */
    uint32_t autoCfg = HWREG(AES_BASE + AES_O_AUTOCFG);

    /* Clear the BUSHALT bit */
    autoCfg &= (uint32_t)~AES_AUTOCFG_BUSHALT_M;

    HWREG(AES_BASE + AES_O_AUTOCFG) = autoCfg;
}

__STATIC_INLINE uint32_t AESGetStatus(void)
{
    return HWREG(AES_BASE + AES_O_STA);
}

__STATIC_INLINE void AESSetTrigger(uint32_t triggerMask)
{
    HWREG(AES_BASE + AES_O_TRG) = triggerMask;
}

__STATIC_INLINE void AESAbort(void)
{
    HWREG(AES_BASE + AES_O_ABORT) = AES_ABORT_ABORTAES_SET;
}

__STATIC_INLINE void AESClearTXT(void)
{
    HWREG(AES_BASE + AES_O_CLR) = AES_CLR_TXT_M;
}

__STATIC_INLINE void AESClearBUF(void)
{
    HWREG(AES_BASE + AES_O_CLR) = AES_CLR_BUF_M;
}

__STATIC_INLINE void AESClearTXTAndBUF(void)
{
    HWREG(AES_BASE + AES_O_CLR) = AES_CLR_TXT_M | AES_CLR_BUF_M;
}

__STATIC_INLINE void AESWriteIV(const uint8_t iv[16])
{
    AESWriteTXT(iv);
}

__STATIC_INLINE void AESWriteIV32(const uint32_t iv[4])
{
    AESWriteTXT32(iv);
}

__STATIC_INLINE void AESClearIV(void)
{
    AESClearTXT();
}

__STATIC_INLINE void AESReadIV(uint8_t iv[16])
{
    AESReadTXT(iv);
}

__STATIC_INLINE void AESReadIV32(uint32_t iv[4])
{
    AESReadTXT32(iv);
}

__STATIC_INLINE uint32_t AESGetRawInterruptStatus(void)
{
    return HWREG(AES_BASE + AES_O_RIS);
}

__STATIC_INLINE void AESSetInterrupt(uint32_t intFlags)
{
    HWREG(AES_BASE + AES_O_ISET) = intFlags;
}

__STATIC_INLINE void AESClearInterrupt(uint32_t intFlags)
{
    HWREG(AES_BASE + AES_O_ICLR) = intFlags;
}

__STATIC_INLINE uint32_t AESGetMaskedInterruptStatus(void)
{
    return HWREG(AES_BASE + AES_O_MIS);
}

__STATIC_INLINE void AESSetIMASK(uint32_t intFlags)
{
    HWREG(AES_BASE + AES_O_IMASK) = intFlags;
}

__STATIC_INLINE void AESSetupDMA(uint32_t dmaConfig)
{
    HWREG(AES_BASE + AES_O_DMA) = dmaConfig;
}

__STATIC_INLINE void AESDisableDMA(void)
{
    HWREG(AES_BASE + AES_O_DMA) = AES_DMA_DONEACT_DIS | AES_DMA_TRGCHB_DIS | AES_DMA_TRGCHA_DIS;
}

#ifdef __cplusplus
}
#endif

#endif /* __AES_H__ */