fsl_dcp.h

/*
 * Copyright 2017-2020 NXP
 * All rights reserved.
 *
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _FSL_DCP_H_
#define _FSL_DCP_H_
 
#include "fsl_common.h"
 
/*******************************************************************************
 * Definitions
 *******************************************************************************/
 
#define FSL_DCP_DRIVER_VERSION (MAKE_VERSION(2, 1, 6))
enum _dcp_status
{
    kStatus_DCP_Again = MAKE_STATUS(kStatusGroup_DCP, 0), 
};
 
typedef enum _dcp_ch_enable
{
    kDCP_chDisable   = 0U,  
    kDCP_ch0Enable   = 1U,  
    kDCP_ch1Enable   = 2U,  
    kDCP_ch2Enable   = 4U,  
    kDCP_ch3Enable   = 8U,  
    kDCP_chEnableAll = 15U, 
} _dcp_ch_enable_t;
 
typedef enum _dcp_ch_int_enable
{
    kDCP_chIntDisable = 0U, 
    kDCP_ch0IntEnable = 1U, 
    kDCP_ch1IntEnable = 2U, 
    kDCP_ch2IntEnable = 4U, 
    kDCP_ch3IntEnable = 8U, 
} _dcp_ch_int_enable_t;
 
typedef enum _dcp_channel
{
    kDCP_Channel0 = (1u << 16), 
    kDCP_Channel1 = (1u << 17), 
    kDCP_Channel2 = (1u << 18), 
    kDCP_Channel3 = (1u << 19), 
} dcp_channel_t;
 
typedef enum _dcp_key_slot
{
    kDCP_KeySlot0     = 0U, 
    kDCP_KeySlot1     = 1U, 
    kDCP_KeySlot2     = 2U, 
    kDCP_KeySlot3     = 3U, 
    kDCP_OtpKey       = 4U, 
    kDCP_OtpUniqueKey = 5U, 
    kDCP_PayloadKey   = 6U, 
} dcp_key_slot_t;
 
typedef enum _dcp_swap
{
    kDCP_NoSwap         = 0x0U,
    kDCP_KeyByteSwap    = 0x40000U,
    kDCP_KeyWordSwap    = 0x80000U,
    kDCP_InputByteSwap  = 0x100000U,
    kDCP_InputWordSwap  = 0x200000U,
    kDCP_OutputByteSwap = 0x400000U,
    kDCP_OutputWordSwap = 0x800000U,
} dcp_swap_t;
 
typedef struct _dcp_work_packet
{
    uint32_t nextCmdAddress;
    uint32_t control0;
    uint32_t control1;
    uint32_t sourceBufferAddress;
    uint32_t destinationBufferAddress;
    uint32_t bufferSize;
    uint32_t payloadPointer;
    uint32_t status;
} dcp_work_packet_t;
 
typedef struct _dcp_handle
{
    dcp_channel_t channel;  
    dcp_key_slot_t keySlot; 
    uint32_t swapConfig;    
    uint32_t keyWord[4];
    uint32_t iv[4];
} dcp_handle_t;
 
typedef struct _dcp_context
{
    uint32_t x[208 / sizeof(uint32_t)];
} dcp_context_t;
 
typedef struct _dcp_config
{
    bool gatherResidualWrites;      
    bool enableContextCaching;      
    bool enableContextSwitching;    
    uint8_t enableChannel;          
    uint8_t enableChannelInterrupt; 
} dcp_config_t;
 
#ifndef DCP_USE_DCACHE
#define DCP_USE_DCACHE 1
#endif
/* 1 - driver supports DCACHE, 0 - drivers does not support DCACHE */
/* When enable (DCP_USE_DCACHE = 1) Input/output buffers and hash ctx should be in */
/* non-cached memory or handled properly (Clean & Invalidate DCACHE) */
 
/*******************************************************************************
 * AES Definitions
 *******************************************************************************/
 
#define DCP_AES_BLOCK_SIZE 16
 /* end of dcp_driver_aes */
 
/*******************************************************************************
 * HASH Definitions
 ******************************************************************************/
/* DCP cannot correctly compute hash for message with zero size. When enabled, driver bypases DCP and returns correct
 * hash value. If you are sure, that the driver will never be called with zero sized message, you can disable this
 * feature to reduce code size */
#define DCP_HASH_CAVP_COMPATIBLE
 
typedef enum _dcp_hash_algo_t
{
    kDCP_Sha1,   
    kDCP_Sha256, 
    kDCP_Crc32,  
} dcp_hash_algo_t;
 
#define DCP_SHA_BLOCK_SIZE  128U               
#define DCP_HASH_BLOCK_SIZE DCP_SHA_BLOCK_SIZE 
#define DCP_HASH_CTX_SIZE 64
 
typedef struct _dcp_hash_ctx_t
{
    uint32_t x[DCP_HASH_CTX_SIZE];
} dcp_hash_ctx_t;
 /* end of dcp_driver_hash */
 
/*******************************************************************************
 * API
 ******************************************************************************/
#if defined(__cplusplus)
extern "C" {
#endif
 
void DCP_Init(DCP_Type *base, const dcp_config_t *config);
 
void DCP_Deinit(DCP_Type *base);
 
void DCP_GetDefaultConfig(dcp_config_t *config);
 
status_t DCP_WaitForChannelComplete(DCP_Type *base, dcp_handle_t *handle);
 /* end of dcp_driver */
 
/*******************************************************************************
 * AES API
 ******************************************************************************/
 
status_t DCP_AES_SetKey(DCP_Type *base, dcp_handle_t *handle, const uint8_t *key, size_t keySize);
 
status_t DCP_AES_EncryptEcb(
    DCP_Type *base, dcp_handle_t *handle, const uint8_t *plaintext, uint8_t *ciphertext, size_t size);
 
status_t DCP_AES_DecryptEcb(
    DCP_Type *base, dcp_handle_t *handle, const uint8_t *ciphertext, uint8_t *plaintext, size_t size);
 
status_t DCP_AES_EncryptCbc(DCP_Type *base,
                            dcp_handle_t *handle,
                            const uint8_t *plaintext,
                            uint8_t *ciphertext,
                            size_t size,
                            const uint8_t iv[16]);
 
status_t DCP_AES_DecryptCbc(DCP_Type *base,
                            dcp_handle_t *handle,
                            const uint8_t *ciphertext,
                            uint8_t *plaintext,
                            size_t size,
                            const uint8_t iv[16]);
 /* end of dcp_driver_aes */
 
status_t DCP_AES_EncryptEcbNonBlocking(DCP_Type *base,
                                       dcp_handle_t *handle,
                                       dcp_work_packet_t *dcpPacket,
                                       const uint8_t *plaintext,
                                       uint8_t *ciphertext,
                                       size_t size);
 
status_t DCP_AES_DecryptEcbNonBlocking(DCP_Type *base,
                                       dcp_handle_t *handle,
                                       dcp_work_packet_t *dcpPacket,
                                       const uint8_t *ciphertext,
                                       uint8_t *plaintext,
                                       size_t size);
 
status_t DCP_AES_EncryptCbcNonBlocking(DCP_Type *base,
                                       dcp_handle_t *handle,
                                       dcp_work_packet_t *dcpPacket,
                                       const uint8_t *plaintext,
                                       uint8_t *ciphertext,
                                       size_t size,
                                       const uint8_t *iv);
 
status_t DCP_AES_DecryptCbcNonBlocking(DCP_Type *base,
                                       dcp_handle_t *handle,
                                       dcp_work_packet_t *dcpPacket,
                                       const uint8_t *ciphertext,
                                       uint8_t *plaintext,
                                       size_t size,
                                       const uint8_t *iv);
 /* end of dcp_nonblocking_driver_aes */
 
/*******************************************************************************
 * HASH API
 ******************************************************************************/
 
status_t DCP_HASH_Init(DCP_Type *base, dcp_handle_t *handle, dcp_hash_ctx_t *ctx, dcp_hash_algo_t algo);
 
status_t DCP_HASH_Update(DCP_Type *base, dcp_hash_ctx_t *ctx, const uint8_t *input, size_t inputSize);
 
status_t DCP_HASH_Finish(DCP_Type *base, dcp_hash_ctx_t *ctx, uint8_t *output, size_t *outputSize);
 
status_t DCP_HASH(DCP_Type *base,
                  dcp_handle_t *handle,
                  dcp_hash_algo_t algo,
                  const uint8_t *input,
                  size_t inputSize,
                  uint8_t *output,
                  size_t *outputSize);
 /* end of dcp_driver_hash */
 
#if defined(__cplusplus)
}
#endif
 
#endif /* _FSL_DCP_H_ */