ctb.h

 
/******************************************************************************
 *
 * Copyright (C) 2022-2023 Maxim Integrated Products, Inc. (now owned by 
 * Analog Devices, Inc.),
 * Copyright (C) 2023-2024 Analog Devices, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 ******************************************************************************/
 
#ifndef LIBRARIES_PERIPHDRIVERS_INCLUDE_MAX32672_CTB_H_
#define LIBRARIES_PERIPHDRIVERS_INCLUDE_MAX32672_CTB_H_
 
/***** Includes *****/
#include "ctb_regs.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* IN ADDITION TO THIS HEADER, FCL WILL BE SUPPORTED AND PROVIDED IN BINARY FORM */
/***** Definitions *****/
 
typedef void (*mxc_ctb_complete_cb_t)(void *req, int result);
 
typedef enum {
    MXC_CTB_FEATURE_DMA = 1 << 0,
    MXC_CTB_FEATURE_ECC = 1 << 1,
    MXC_CTB_FEATURE_CRC = 1 << 2,
    MXC_CTB_FEATURE_HASH = 1 << 4,
    MXC_CTB_FEATURE_CIPHER = 1 << 5,
    MXC_CTB_FEATURE_TRNG = 1 << 6
} mxc_ctb_features_t;
 
/* ************************************************************************* */
/* DMA Definitions                                                           */
/* ************************************************************************* */
 
struct _mxc_ctb_dma_req_t {
    uint8_t *sourceBuffer; 
    uint8_t *destBuffer; 
    uint32_t length; 
    mxc_ctb_complete_cb_t callback; 
} typedef mxc_ctb_dma_req_t;
 
typedef enum {
    MXC_CTB_DMA_READ_FIFO_DMA = MXC_V_CTB_CTRL_RDSRC_DMAORAPB,
    MXC_CTB_DMA_READ_FIFO_RNG = MXC_V_CTB_CTRL_RDSRC_RNG
} mxc_ctb_dma_read_source_t;
 
typedef enum {
    MXC_CTB_DMA_WRITE_FIFO_CIPHER = MXC_V_CTB_CTRL_WRSRC_CIPHEROUTPUT,
    MXC_CTB_DMA_WRITE_FIFO_READ_FIFO = MXC_V_CTB_CTRL_WRSRC_READFIFO,
    MXC_CTB_DMA_WRITE_FIFO_NONE = MXC_V_CTB_CTRL_WRSRC_NONE
} mxc_ctb_dma_write_source_t;
 
/* ************************************************************************* */
/* ECC Definitions                                                           */
/* ************************************************************************* */
 
struct _mxc_ctb_ecc_req_t {
    uint8_t *dataBuffer;
    uint32_t dataLen;
    uint32_t checksum;
    mxc_ctb_complete_cb_t callback;
} typedef mxc_ctb_ecc_req_t;
 
struct _mxc_ctb_crc_req_t {
    uint8_t *dataBuffer;
    uint32_t dataLen;
    uint32_t resultCRC;
    mxc_ctb_complete_cb_t callback;
} typedef mxc_ctb_crc_req_t;
 
typedef enum { MXC_CTB_CRC_LSB_FIRST, MXC_CTB_CRC_MSB_FIRST } mxc_ctb_crc_bitorder_t;
 
/* ************************************************************************* */
/* Hash Definitions                                                                            */
/* ************************************************************************* */
 
struct _mxc_ctb_hash_req_t {
    uint8_t *msg;
    uint32_t len;
    uint8_t *hash;
    mxc_ctb_complete_cb_t callback;
} typedef mxc_ctb_hash_req_t;
 
typedef enum {
    MXC_CTB_HASH_DIS = MXC_V_CTB_HASH_CTRL_HASH_DIS, // Disable
    MXC_CTB_HASH_SHA1 = MXC_V_CTB_HASH_CTRL_HASH_SHA1, // Select SHA1
    MXC_CTB_HASH_SHA224 = MXC_V_CTB_HASH_CTRL_HASH_SHA224, // Select SHA224
    MXC_CTB_HASH_SHA256 = MXC_V_CTB_HASH_CTRL_HASH_SHA256, // Select SHA256
    MXC_CTB_HASH_SHA384 = MXC_V_CTB_HASH_CTRL_HASH_SHA384, // Select SHA384
    MXC_CTB_HASH_SHA512 = MXC_V_CTB_HASH_CTRL_HASH_SHA512 // Select SHA384
} mxc_ctb_hash_func_t;
 
typedef enum {
    MXC_CTB_HASH_SOURCE_INFIFO = 0,
    MXC_CTB_HASH_SOURCE_OUTFIFO = 1
} mxc_ctb_hash_source_t;
 
/* ************************************************************************* */
/* Cipher Definitions                                                                          */
/* ************************************************************************* */
 
struct _mxc_ctb_cipher_req_t {
    uint8_t *plaintext;
    uint32_t ptLen;
    uint8_t *iv;
    uint8_t *ciphertext;
    mxc_ctb_complete_cb_t callback;
} typedef mxc_ctb_cipher_req_t;
 
typedef enum {
    MXC_CTB_MODE_ECB = MXC_V_CTB_CIPHER_CTRL_MODE_ECB, 
    MXC_CTB_MODE_CBC = MXC_V_CTB_CIPHER_CTRL_MODE_CBC, 
    MXC_CTB_MODE_CFB = MXC_V_CTB_CIPHER_CTRL_MODE_CFB, 
    MXC_CTB_MODE_CTR = MXC_V_CTB_CIPHER_CTRL_MODE_CTR, 
    MXC_CTB_MODE_OFB = MXC_V_CTB_CIPHER_CTRL_MODE_OFB 
} mxc_ctb_cipher_mode_t;
 
typedef enum {
    MXC_CTB_CIPHER_DIS = MXC_V_CTB_CIPHER_CTRL_CIPHER_DIS, 
    MXC_CTB_CIPHER_AES128 = MXC_V_CTB_CIPHER_CTRL_CIPHER_AES128, 
    MXC_CTB_CIPHER_AES192 = MXC_V_CTB_CIPHER_CTRL_CIPHER_AES192, 
    MXC_CTB_CIPHER_AES256 = MXC_V_CTB_CIPHER_CTRL_CIPHER_AES256, 
    MXC_CTB_CIPHER_DES = MXC_V_CTB_CIPHER_CTRL_CIPHER_DES, 
    MXC_CTB_CIPHER_TDES = MXC_V_CTB_CIPHER_CTRL_CIPHER_TDES 
} mxc_ctb_cipher_t;
 
typedef enum {
    MXC_CTB_CIPHER_KEY_SOFTWARE = 0,
    MXC_CTB_CIPHER_KEY_AES_KEY2 = 2,
    MXC_CTB_CIPHER_KEY_AES_KEY3 = 3
} mxc_ctb_cipher_key_t;
 
typedef enum { MXC_CTB_CIPHER_ENCRYPTION, MXC_CTB_CIPHER_DECRYPTION } mxc_ctb_cipher_operation_t;
 
/***** Function Prototypes *****/
 
/* ************************************************************************* */
/* Global Control/Configuration functions                                    */
/* ************************************************************************* */
 
int MXC_CTB_Init(uint32_t features);
 
uint32_t MXC_CTB_CheckFeatures(void);
 
void MXC_CTB_EnableInt(void);
 
void MXC_CTB_DisableInt(void);
 
int MXC_CTB_Ready(void);
 
void MXC_CTB_DoneClear(uint32_t features);
 
uint32_t MXC_CTB_Done(void);
 
void MXC_CTB_Reset(uint32_t features);
 
void MXC_CTB_CacheInvalidate(void);
 
int MXC_CTB_Shutdown(uint32_t features);
 
uint32_t MXC_CTB_GetEnabledFeatures(void);
 
void MXC_CTB_Handler(void);
 
/************************************/
/* CTB DMA - Used for all features  */
/************************************/
 
void MXC_CTB_DMA_SetReadSource(mxc_ctb_dma_read_source_t source);
 
mxc_ctb_dma_read_source_t MXC_CTB_DMA_GetReadSource(void);
 
void MXC_CTB_DMA_SetWriteSource(mxc_ctb_dma_write_source_t source);
 
mxc_ctb_dma_write_source_t MXC_CTB_DMA_GetWriteSource(void);
 
void MXC_CTB_DMA_SetSource(uint8_t *source);
 
void MXC_CTB_DMA_SetDestination(uint8_t *dest);
 
int MXC_CTB_DMA_SetupOperation(mxc_ctb_dma_req_t *req);
 
int MXC_CTB_DMA_DoOperation(mxc_ctb_dma_req_t *req);
 
void MXC_CTB_DMA_StartTransfer(uint32_t length);
 
/* ************************************************************************* */
/* True Random Number Generator (TRNG) functions                             */
/* ************************************************************************* */
 
int MXC_CTB_TRNG_RandomInt(void);
 
int MXC_CTB_TRNG_Random(uint8_t *data, uint32_t len);
 
void MXC_CTB_TRNG_RandomAsync(uint8_t *data, uint32_t len, mxc_ctb_complete_cb_t callback);
 
/* ************************************************************************* */
/* Error Correction Code (ECC) functions                                     */
/* ************************************************************************* */
 
/*******************************/
/* Low Level Functions         */
/*******************************/
 
void MXC_CTB_ECC_Enable(void);
 
void MXC_CTB_ECC_Disable(void);
 
uint32_t MXC_CTB_ECC_GetResult(void);
 
/*******************************/
/* High Level Functions        */
/*******************************/
 
int MXC_CTB_ECC_Compute(mxc_ctb_ecc_req_t *req);
 
int MXC_CTB_ECC_ErrorCheck(mxc_ctb_ecc_req_t *req);
 
void MXC_CTB_ECC_ComputeAsync(mxc_ctb_ecc_req_t *req);
 
void MXC_CTB_ECC_ErrorCheckAsync(mxc_ctb_ecc_req_t *req);
 
/* ************************************************************************* */
/* Cyclic Redundancy Check (CRC) functions                                   */
/* ************************************************************************* */
 
/*******************************/
/* Low Level Functions         */
/*******************************/
 
void MXC_CTB_CRC_SetDirection(mxc_ctb_crc_bitorder_t bitOrder);
 
mxc_ctb_crc_bitorder_t MXC_CTB_CRC_GetDirection(void);
 
void MXC_CTB_CRC_SetPoly(uint32_t poly);
 
uint32_t MXC_CTB_CRC_GetPoly(void);
 
uint32_t MXC_CTB_CRC_GetResult(void);
 
void MXC_CTB_CRC_SetInitialValue(uint32_t seed);
 
void MXC_CTB_CRC_SetFinalXORValue(uint32_t xor);
 
/*******************************/
/* High Level Functions        */
/*******************************/
 
int MXC_CTB_CRC_Compute(mxc_ctb_crc_req_t *req);
 
void MXC_CTB_CRC_ComputeAsync(mxc_ctb_crc_req_t *req);
 
/* ************************************************************************* */
/* Hash functions                                                            */
/* ************************************************************************* */
 
/***********************/
/* Low Level Functions */
/***********************/
 
unsigned int MXC_CTB_Hash_GetBlockSize(mxc_ctb_hash_func_t function);
 
unsigned int MXC_CTB_Hash_GetDigestSize(mxc_ctb_hash_func_t function);
 
void MXC_CTB_Hash_SetFunction(mxc_ctb_hash_func_t function);
 
mxc_ctb_hash_func_t MXC_CTB_Hash_GetFunction(void);
 
void MXC_CTB_Hash_SetAutoPad(int pad);
 
int MXC_CTB_Hash_GetAutoPad(void);
 
void MXC_CTB_Hash_GetResult(uint8_t *digest, int *len);
 
void MXC_CTB_Hash_SetMessageSize(uint32_t size);
 
void MXC_CTB_Hash_SetSource(mxc_ctb_hash_source_t source);
 
mxc_ctb_hash_source_t MXC_CTB_Hash_GetSource(void);
 
void MXC_CTB_Hash_InitializeHash(void);
 
/************************/
/* High Level Functions */
/************************/
 
int MXC_CTB_Hash_Compute(mxc_ctb_hash_req_t *req);
 
void MXC_CTB_Hash_ComputeAsync(mxc_ctb_hash_req_t *req);
 
/* ************************************************************************* */
/* Cipher functions                                                          */
/* ************************************************************************* */
 
/************************/
/* Low Level Functions  */
/************************/
 
unsigned int MXC_CTB_Cipher_GetKeySize(mxc_ctb_cipher_t cipher);
 
unsigned int MXC_CTB_Cipher_GetBlockSize(mxc_ctb_cipher_t cipher);
 
void MXC_CTB_Cipher_SetMode(mxc_ctb_cipher_mode_t mode);
 
mxc_ctb_cipher_mode_t MXC_CTB_Cipher_GetMode(void);
 
void MXC_CTB_Cipher_SetCipher(mxc_ctb_cipher_t cipher);
 
mxc_ctb_cipher_t MXC_CTB_Cipher_GetCipher(void);
 
void MXC_CTB_Cipher_SetKeySource(mxc_ctb_cipher_key_t source);
 
mxc_ctb_cipher_key_t MXC_CTB_Cipher_GetKeySource(void);
 
void MXC_CTB_Cipher_LoadKey(void);
 
void MXC_CTB_Cipher_SetOperation(mxc_ctb_cipher_operation_t operation);
 
void MXC_CTB_Cipher_SetKey(uint8_t *key, uint32_t len);
 
void MXC_CTB_Cipher_SetIV(uint8_t *iv, uint32_t len);
 
void MXC_CTB_Cipher_GetIV(uint8_t *ivOut, uint32_t len);
 
/************************/
/* High Level Functions */
/************************/
 
int MXC_CTB_Cipher_Encrypt(mxc_ctb_cipher_req_t *req);
 
int MXC_CTB_Cipher_Decrypt(mxc_ctb_cipher_req_t *req);
 
void MXC_CTB_Cipher_EncryptAsync(mxc_ctb_cipher_req_t *req);
 
void MXC_CTB_Cipher_DecryptAsync(mxc_ctb_cipher_req_t *req);
 
#ifdef __cplusplus
}
#endif
#endif // LIBRARIES_PERIPHDRIVERS_INCLUDE_MAX32672_CTB_H_