| /* |
| * Copyright (c) 2015, Freescale Semiconductor, Inc. |
| * Copyright 2016-2017 NXP |
| * |
| * Redistribution and use in source and binary forms, with or without modification, |
| * are permitted provided that the following conditions are met: |
| * |
| * o Redistributions of source code must retain the above copyright notice, this list |
| * of conditions and the following disclaimer. |
| * |
| * o 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. |
| * |
| * o 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. |
| */ |
| |
| #include "fsl_ltc_edma.h" |
| |
| /******************************************************************************* |
| * Definitions |
| ******************************************************************************/ |
| |
| /*<! Structure definition for ltc_edma_private_handle_t. The structure is private. */ |
| typedef struct _ltc_edma_private_handle |
| { |
| LTC_Type *base; |
| ltc_edma_handle_t *handle; |
| } ltc_edma_private_handle_t; |
| |
| /******************************************************************************* |
| * Variables |
| ******************************************************************************/ |
| |
| /*<! Private handle only used for internally. */ |
| static ltc_edma_private_handle_t s_edmaPrivateHandle[FSL_FEATURE_SOC_LTC_COUNT]; |
| |
| /* Array of LTC peripheral base address. */ |
| static LTC_Type *const s_ltcBase[] = LTC_BASE_PTRS; |
| |
| /******************************************************************************* |
| * Definitions |
| ******************************************************************************/ |
| /* State machine state.*/ |
| #define LTC_SM_STATE_START 0x0000u |
| #define LTC_SM_STATE_FINISH 0xFFFFu |
| |
| /*! Full word representing the actual bit values for the LTC mode register. */ |
| typedef uint32_t ltc_mode_t; |
| |
| #define LTC_FIFO_SZ_MAX_DOWN_ALGN (0xff0u) |
| #define LTC_MD_ALG_AES (0x10U) /*!< Bit field value for LTC_MD_ALG: AES */ |
| #define LTC_MD_ALG_DES (0x20U) /*!< Bit field value for LTC_MD_ALG: DES */ |
| #define LTC_MD_ALG_TRIPLE_DES (0x21U) /*!< Bit field value for LTC_MD_ALG: 3DES */ |
| #define LTC_MDPK_ALG_PKHA (0x80U) /*!< Bit field value for LTC_MDPK_ALG: PKHA */ |
| #define LTC_MD_ENC_DECRYPT (0U) /*!< Bit field value for LTC_MD_ENC: Decrypt. */ |
| #define LTC_MD_ENC_ENCRYPT (0x1U) /*!< Bit field value for LTC_MD_ENC: Encrypt. */ |
| #define LTC_MD_AS_UPDATE (0U) /*!< Bit field value for LTC_MD_AS: Update */ |
| #define LTC_MD_AS_INITIALIZE (0x1U) /*!< Bit field value for LTC_MD_AS: Initialize */ |
| #define LTC_MD_AS_FINALIZE (0x2U) /*!< Bit field value for LTC_MD_AS: Finalize */ |
| #define LTC_MD_AS_INIT_FINAL (0x3U) /*!< Bit field value for LTC_MD_AS: Initialize/Finalize */ |
| |
| enum _ltc_md_dk_bit_shift |
| { |
| kLTC_ModeRegBitShiftDK = 12U, |
| }; |
| |
| typedef enum _ltc_algorithm |
| { |
| kLTC_AlgorithmAES = LTC_MD_ALG_AES << LTC_MD_ALG_SHIFT, |
| #if defined(FSL_FEATURE_LTC_HAS_DES) && FSL_FEATURE_LTC_HAS_DES |
| kLTC_AlgorithmDES = LTC_MD_ALG_DES << LTC_MD_ALG_SHIFT, |
| kLTC_Algorithm3DES = LTC_MD_ALG_TRIPLE_DES << LTC_MD_ALG_SHIFT, |
| #endif /* FSL_FEATURE_LTC_HAS_DES */ |
| } ltc_algorithm_t; |
| |
| typedef enum _ltc_mode_symmetric_alg |
| { |
| kLTC_ModeCTR = 0x00U << LTC_MD_AAI_SHIFT, |
| kLTC_ModeCBC = 0x10U << LTC_MD_AAI_SHIFT, |
| kLTC_ModeECB = 0x20U << LTC_MD_AAI_SHIFT, |
| kLTC_ModeCFB = 0x30U << LTC_MD_AAI_SHIFT, |
| kLTC_ModeOFB = 0x40U << LTC_MD_AAI_SHIFT, |
| kLTC_ModeCMAC = 0x60U << LTC_MD_AAI_SHIFT, |
| kLTC_ModeXCBCMAC = 0x70U << LTC_MD_AAI_SHIFT, |
| kLTC_ModeCCM = 0x80U << LTC_MD_AAI_SHIFT, |
| kLTC_ModeGCM = 0x90U << LTC_MD_AAI_SHIFT, |
| } ltc_mode_symmetric_alg_t; |
| |
| typedef enum _ltc_mode_encrypt |
| { |
| kLTC_ModeDecrypt = LTC_MD_ENC_DECRYPT << LTC_MD_ENC_SHIFT, |
| kLTC_ModeEncrypt = LTC_MD_ENC_ENCRYPT << LTC_MD_ENC_SHIFT, |
| } ltc_mode_encrypt_t; |
| |
| typedef enum _ltc_mode_algorithm_state |
| { |
| kLTC_ModeUpdate = LTC_MD_AS_UPDATE << LTC_MD_AS_SHIFT, |
| kLTC_ModeInit = LTC_MD_AS_INITIALIZE << LTC_MD_AS_SHIFT, |
| kLTC_ModeFinalize = LTC_MD_AS_FINALIZE << LTC_MD_AS_SHIFT, |
| kLTC_ModeInitFinal = LTC_MD_AS_INIT_FINAL << LTC_MD_AS_SHIFT |
| } ltc_mode_algorithm_state_t; |
| |
| /******************************************************************************* |
| * Prototypes |
| ******************************************************************************/ |
| |
| extern status_t ltc_get_context(LTC_Type *base, uint8_t *dest, uint8_t dataSize, uint8_t startIndex); |
| extern status_t ltc_set_context(LTC_Type *base, const uint8_t *data, uint8_t dataSize, uint8_t startIndex); |
| extern status_t ltc_symmetric_update(LTC_Type *base, |
| const uint8_t *key, |
| uint8_t keySize, |
| ltc_algorithm_t alg, |
| ltc_mode_symmetric_alg_t mode, |
| ltc_mode_encrypt_t enc); |
| extern void ltc_memcpy(void *dst, const void *src, size_t size); |
| extern bool ltc_check_key_size(const uint32_t keySize); |
| extern status_t ltc_wait(LTC_Type *base); |
| extern void ltc_clear_all(LTC_Type *base, bool addPKHA); |
| extern status_t ltc_3des_check_input_args(ltc_mode_symmetric_alg_t modeAs, |
| uint32_t size, |
| const uint8_t *key1, |
| const uint8_t *key2); |
| extern void ltc_symmetric_process(LTC_Type *base, uint32_t inSize, const uint8_t **inData, uint8_t **outData); |
| extern status_t ltc_symmetric_process_data(LTC_Type *base, const uint8_t *inData, uint32_t inSize, uint8_t *outData); |
| |
| static uint32_t LTC_GetInstance(LTC_Type *base); |
| static void ltc_symmetric_process_EDMA(LTC_Type *base, uint32_t inSize, const uint8_t **inData, uint8_t **outData); |
| static status_t ltc_process_message_in_sessions_EDMA(LTC_Type *base, ltc_edma_handle_t *handle); |
| |
| /******************************************************************************* |
| * Code |
| ******************************************************************************/ |
| |
| /******************************************************************************* |
| * LTC Common code static |
| ******************************************************************************/ |
| |
| /*! |
| * @brief Splits the LTC job into sessions. Used for CBC, CTR, CFB, OFB cipher block modes. |
| * |
| * @param base LTC peripheral base address |
| * @param inData Input data to process. |
| * @param inSize Input size of the input buffer. |
| * @param outData Output data buffer. |
| */ |
| static status_t ltc_process_message_in_sessions_EDMA(LTC_Type *base, ltc_edma_handle_t *handle) |
| { |
| status_t retval; |
| bool exit_sm = false; |
| |
| handle->modeReg = base->MD; |
| retval = kStatus_Success; |
| |
| if ((!handle->inData) || (!handle->outData)) |
| { |
| handle->state = LTC_SM_STATE_FINISH; /* END */ |
| retval = kStatus_InvalidArgument; |
| } |
| |
| while (exit_sm == false) |
| { |
| switch (handle->state) |
| { |
| case LTC_SM_STATE_START: |
| if (handle->size) |
| { |
| uint32_t sz; |
| |
| if (handle->size <= LTC_FIFO_SZ_MAX_DOWN_ALGN) |
| { |
| sz = handle->size; |
| } |
| else |
| { |
| sz = LTC_FIFO_SZ_MAX_DOWN_ALGN; |
| } |
| |
| /* retval = ltc_symmetric_process_data_EDMA(base, handle->inData, sz, handle->outData); */ |
| { |
| uint32_t lastSize; |
| uint32_t inSize = sz; |
| |
| /* Write the data size. */ |
| base->DS = inSize; |
| |
| /* Split the inSize into full 16-byte chunks and last incomplete block due to LTC AES OFIFO |
| * errata */ |
| if (inSize <= 16u) |
| { |
| lastSize = inSize; |
| inSize = 0; |
| } |
| else |
| { |
| /* Process all 16-byte data chunks. */ |
| lastSize = inSize % 16u; |
| if (lastSize == 0) |
| { |
| lastSize = 16; |
| inSize -= 16; |
| } |
| else |
| { |
| inSize -= |
| lastSize; /* inSize will be rounded down to 16 byte boundary. remaining bytes in |
| lastSize */ |
| } |
| } |
| |
| if (inSize) |
| { |
| handle->size -= inSize; |
| ltc_symmetric_process_EDMA(base, inSize, &handle->inData, &handle->outData); |
| exit_sm = true; |
| } |
| else if (lastSize) |
| { |
| ltc_symmetric_process(base, lastSize, &handle->inData, &handle->outData); |
| retval = ltc_wait(base); |
| handle->size -= lastSize; |
| } |
| else |
| { |
| } |
| } |
| } |
| else |
| { |
| handle->state = LTC_SM_STATE_FINISH; |
| } |
| break; |
| case LTC_SM_STATE_FINISH: |
| default: |
| base->MD = handle->modeReg; |
| |
| ltc_clear_all(base, false); |
| |
| if (handle->callback) |
| { |
| handle->callback(base, handle, retval, handle->userData); |
| } |
| exit_sm = true; |
| break; |
| } |
| } |
| |
| return retval; |
| } |
| |
| /*! |
| * @brief Splits the LTC job into sessions. Used for CBC, CTR, CFB, OFB cipher block modes. |
| * |
| * @param base LTC peripheral base address |
| * @param inData Input data to process. |
| * @param inSize Input size of the input buffer. |
| * @param outData Output data buffer. |
| */ |
| static status_t ltc_process_message_in_sessions_ctr_EDMA(LTC_Type *base, ltc_edma_handle_t *handle) |
| { |
| status_t retval; |
| bool exit_sm = false; |
| |
| handle->modeReg = base->MD; |
| retval = kStatus_Success; |
| |
| if ((!handle->inData) || (!handle->outData)) |
| { |
| handle->state = LTC_SM_STATE_FINISH; |
| retval = kStatus_InvalidArgument; |
| } |
| |
| while (exit_sm == false) |
| { |
| switch (handle->state) |
| { |
| case LTC_SM_STATE_START: |
| if (handle->size) |
| { |
| uint32_t sz; |
| |
| if (handle->size <= LTC_FIFO_SZ_MAX_DOWN_ALGN) |
| { |
| sz = handle->size; |
| } |
| else |
| { |
| sz = LTC_FIFO_SZ_MAX_DOWN_ALGN; |
| } |
| |
| /* retval = ltc_symmetric_process_data_EDMA(base, handle->inData, sz, handle->outData); */ |
| { |
| uint32_t lastSize; |
| uint32_t inSize = sz; |
| |
| /* Write the data size. */ |
| base->DS = inSize; |
| |
| /* Split the inSize into full 16-byte chunks and last incomplete block due to LTC AES OFIFO |
| * errata */ |
| if (inSize <= 16u) |
| { |
| lastSize = inSize; |
| inSize = 0; |
| } |
| else |
| { |
| /* Process all 16-byte data chunks. */ |
| lastSize = inSize % 16u; |
| if (lastSize == 0) |
| { |
| lastSize = 16; |
| inSize -= 16; |
| } |
| else |
| { |
| inSize -= |
| lastSize; /* inSize will be rounded down to 16 byte boundary. remaining bytes in |
| lastSize */ |
| } |
| } |
| |
| if (inSize) |
| { |
| handle->size -= inSize; |
| ltc_symmetric_process_EDMA(base, inSize, &handle->inData, &handle->outData); |
| exit_sm = true; |
| } |
| else if (lastSize) |
| { |
| ltc_symmetric_process(base, lastSize, &handle->inData, &handle->outData); |
| retval = ltc_wait(base); |
| handle->size -= lastSize; |
| } |
| else |
| { |
| } |
| } |
| } |
| else |
| { |
| handle->state = LTC_SM_STATE_FINISH; |
| } |
| break; |
| case LTC_SM_STATE_FINISH: |
| default: |
| base->MD = handle->modeReg; |
| |
| /* CTR final phase.*/ |
| if (kStatus_Success == retval) |
| { |
| const uint8_t *input = handle->inData; |
| uint8_t *output = handle->outData; |
| |
| if ((handle->counterlast != NULL) && (handle->lastSize)) |
| { |
| uint8_t zeroes[16] = {0}; |
| ltc_mode_t modeReg; |
| |
| modeReg = (uint32_t)kLTC_AlgorithmAES | (uint32_t)kLTC_ModeCTR | (uint32_t)kLTC_ModeEncrypt; |
| /* Write the mode register to the hardware. */ |
| base->MD = modeReg | (uint32_t)kLTC_ModeFinalize; |
| |
| /* context is re-used (CTRi) */ |
| |
| /* Process data and return status. */ |
| retval = ltc_symmetric_process_data(base, input, handle->lastSize, output); |
| if (kStatus_Success == retval) |
| { |
| if (handle->szLeft) |
| { |
| *handle->szLeft = 16U - handle->lastSize; |
| } |
| |
| /* Initialize algorithm state. */ |
| base->MD = modeReg | (uint32_t)kLTC_ModeUpdate; |
| |
| /* context is re-used (CTRi) */ |
| |
| /* Process data and return status. */ |
| retval = ltc_symmetric_process_data(base, zeroes, 16U, handle->counterlast); |
| } |
| } |
| if (kStatus_Success == retval) |
| { |
| ltc_get_context(base, &handle->counter[0], 16U, 4U); |
| |
| ltc_clear_all(base, false); |
| } |
| } |
| |
| if (handle->callback) |
| { |
| handle->callback(base, handle, retval, handle->userData); |
| } |
| |
| exit_sm = true; |
| break; |
| } |
| } |
| |
| return retval; |
| } |
| |
| /******************************************************************************* |
| * AES Code public |
| ******************************************************************************/ |
| |
| status_t LTC_AES_EncryptEcbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *plaintext, |
| uint8_t *ciphertext, |
| uint32_t size, |
| const uint8_t *key, |
| uint32_t keySize) |
| { |
| status_t retval; |
| |
| if ((ltc_check_key_size(keySize) == 0) || (size < 16u) || |
| (size % 16u)) /* ECB mode, size must be 16-byte multiple */ |
| { |
| if (handle->callback) |
| { |
| handle->callback(base, handle, kStatus_InvalidArgument, handle->userData); |
| } |
| |
| return kStatus_InvalidArgument; |
| } |
| |
| /* Initialize algorithm state. */ |
| ltc_symmetric_update(base, key, keySize, kLTC_AlgorithmAES, kLTC_ModeECB, kLTC_ModeEncrypt); |
| |
| /* Process data and return status. */ |
| handle->inData = &plaintext[0]; |
| handle->outData = &ciphertext[0]; |
| handle->size = size; |
| handle->state = LTC_SM_STATE_START; |
| handle->state_machine = ltc_process_message_in_sessions_EDMA; |
| retval = handle->state_machine(base, handle); |
| return retval; |
| } |
| |
| status_t LTC_AES_DecryptEcbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *ciphertext, |
| uint8_t *plaintext, |
| uint32_t size, |
| const uint8_t *key, |
| uint32_t keySize, |
| ltc_aes_key_t keyType) |
| { |
| status_t status; |
| |
| if ((ltc_check_key_size(keySize) == 0) || (size < 16u) || |
| (size % 16u)) /* ECB mode, size must be 16-byte multiple */ |
| { |
| if (handle->callback) |
| { |
| handle->callback(base, handle, kStatus_InvalidArgument, handle->userData); |
| } |
| |
| return kStatus_InvalidArgument; |
| } |
| |
| /* Initialize algorithm state. */ |
| ltc_symmetric_update(base, key, keySize, kLTC_AlgorithmAES, kLTC_ModeECB, kLTC_ModeDecrypt); |
| |
| /* set DK bit in the LTC Mode Register AAI field for directly loaded decrypt keys */ |
| if (keyType == kLTC_DecryptKey) |
| { |
| base->MD |= (1U << kLTC_ModeRegBitShiftDK); |
| } |
| |
| /* Process data and return status. */ |
| handle->inData = &ciphertext[0]; |
| handle->outData = &plaintext[0]; |
| handle->size = size; |
| handle->state = LTC_SM_STATE_START; |
| handle->state_machine = ltc_process_message_in_sessions_EDMA; |
| status = handle->state_machine(base, handle); |
| |
| return status; |
| } |
| |
| status_t LTC_AES_EncryptCbcEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *plaintext, |
| uint8_t *ciphertext, |
| uint32_t size, |
| const uint8_t iv[LTC_AES_IV_SIZE], |
| const uint8_t *key, |
| uint32_t keySize) |
| { |
| status_t retval; |
| |
| if ((ltc_check_key_size(keySize) == 0) || (size < 16u) || |
| (size % 16u)) /* CBC mode, size must be 16-byte multiple */ |
| { |
| if (handle->callback) |
| { |
| handle->callback(base, handle, kStatus_InvalidArgument, handle->userData); |
| } |
| |
| return kStatus_InvalidArgument; |
| } |
| |
| /* Initialize algorithm state. */ |
| ltc_symmetric_update(base, key, keySize, kLTC_AlgorithmAES, kLTC_ModeCBC, kLTC_ModeEncrypt); |
| |
| /* Write IV data to the context register. */ |
| ltc_set_context(base, &iv[0], LTC_AES_IV_SIZE, 0); |
| |
| /* Process data and return status. */ |
| handle->inData = &plaintext[0]; |
| handle->outData = &ciphertext[0]; |
| handle->size = size; |
| handle->state = LTC_SM_STATE_START; |
| handle->state_machine = ltc_process_message_in_sessions_EDMA; |
| retval = handle->state_machine(base, handle); |
| return retval; |
| } |
| |
| status_t LTC_AES_DecryptCbcEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *ciphertext, |
| uint8_t *plaintext, |
| uint32_t size, |
| const uint8_t iv[LTC_AES_IV_SIZE], |
| const uint8_t *key, |
| uint32_t keySize, |
| ltc_aes_key_t keyType) |
| { |
| status_t retval; |
| |
| if ((ltc_check_key_size(keySize) == 0) || (size < 16u) || |
| (size % 16u)) /* CBC mode, size must be 16-byte multiple */ |
| { |
| if (handle->callback) |
| { |
| handle->callback(base, handle, kStatus_InvalidArgument, handle->userData); |
| } |
| |
| return kStatus_InvalidArgument; |
| } |
| |
| /* set DK bit in the LTC Mode Register AAI field for directly loaded decrypt keys */ |
| if (keyType == kLTC_DecryptKey) |
| { |
| base->MD |= (1U << kLTC_ModeRegBitShiftDK); |
| } |
| |
| /* Initialize algorithm state. */ |
| ltc_symmetric_update(base, key, keySize, kLTC_AlgorithmAES, kLTC_ModeCBC, kLTC_ModeDecrypt); |
| |
| /* Write IV data to the context register. */ |
| ltc_set_context(base, &iv[0], LTC_AES_IV_SIZE, 0); |
| |
| /* Process data and return status. */ |
| handle->inData = &ciphertext[0]; |
| handle->outData = &plaintext[0]; |
| handle->size = size; |
| handle->state = LTC_SM_STATE_START; |
| handle->state_machine = ltc_process_message_in_sessions_EDMA; |
| retval = handle->state_machine(base, handle); |
| return retval; |
| } |
| |
| status_t LTC_AES_CryptCtrEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *input, |
| uint8_t *output, |
| uint32_t size, |
| uint8_t counter[LTC_AES_BLOCK_SIZE], |
| const uint8_t *key, |
| uint32_t keySize, |
| uint8_t counterlast[LTC_AES_BLOCK_SIZE], |
| uint32_t *szLeft) |
| { |
| status_t retval; |
| uint32_t lastSize; |
| |
| if (!ltc_check_key_size(keySize)) |
| { |
| if (handle->callback) |
| { |
| handle->callback(base, handle, kStatus_InvalidArgument, handle->userData); |
| } |
| return kStatus_InvalidArgument; |
| } |
| |
| lastSize = 0U; |
| if (counterlast != NULL) |
| { |
| /* Split the size into full 16-byte chunks and last incomplete block due to LTC AES OFIFO errata */ |
| if (size <= 16U) |
| { |
| lastSize = size; |
| size = 0U; |
| } |
| else |
| { |
| /* Process all 16-byte data chunks. */ |
| lastSize = size % 16U; |
| if (lastSize == 0U) |
| { |
| lastSize = 16U; |
| size -= 16U; |
| } |
| else |
| { |
| size -= lastSize; /* size will be rounded down to 16 byte boundary. remaining bytes in lastSize */ |
| } |
| } |
| } |
| |
| /* Initialize algorithm state. */ |
| ltc_symmetric_update(base, key, keySize, kLTC_AlgorithmAES, kLTC_ModeCTR, kLTC_ModeEncrypt); |
| |
| /* Write initial counter data to the context register. |
| * NOTE the counter values start at 4-bytes offset into the context. */ |
| ltc_set_context(base, &counter[0], 16U, 4U); |
| |
| /* Process data and return status. */ |
| handle->inData = &input[0]; |
| handle->outData = &output[0]; |
| handle->size = size; |
| handle->state = LTC_SM_STATE_START; |
| handle->state_machine = ltc_process_message_in_sessions_ctr_EDMA; |
| |
| handle->counter = counter; |
| handle->key = key; |
| handle->keySize = keySize; |
| handle->counterlast = counterlast; |
| handle->szLeft = szLeft; |
| handle->lastSize = lastSize; |
| retval = handle->state_machine(base, handle); |
| |
| return retval; |
| } |
| |
| #if defined(FSL_FEATURE_LTC_HAS_DES) && FSL_FEATURE_LTC_HAS_DES |
| /******************************************************************************* |
| * DES / 3DES Code static |
| ******************************************************************************/ |
| static status_t ltc_des_process_EDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *input, |
| uint8_t *output, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key[LTC_DES_KEY_SIZE], |
| ltc_mode_symmetric_alg_t modeAs, |
| ltc_mode_encrypt_t modeEnc) |
| { |
| status_t retval; |
| |
| /* all but OFB, size must be 8-byte multiple */ |
| if ((modeAs != kLTC_ModeOFB) && ((size < 8u) || (size % 8u))) |
| { |
| if (handle->callback) |
| { |
| handle->callback(base, handle, kStatus_InvalidArgument, handle->userData); |
| } |
| return kStatus_InvalidArgument; |
| } |
| |
| /* Initialize algorithm state. */ |
| ltc_symmetric_update(base, &key[0], LTC_DES_KEY_SIZE, kLTC_AlgorithmDES, modeAs, modeEnc); |
| |
| if ((modeAs != kLTC_ModeECB)) |
| { |
| ltc_set_context(base, iv, LTC_DES_IV_SIZE, 0); |
| } |
| |
| /* Process data and return status. */ |
| handle->inData = input; |
| handle->outData = output; |
| handle->size = size; |
| handle->state = LTC_SM_STATE_START; |
| handle->state_machine = ltc_process_message_in_sessions_EDMA; |
| retval = handle->state_machine(base, handle); |
| |
| return retval; |
| } |
| |
| static status_t ltc_3des_process_EDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *input, |
| uint8_t *output, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE], |
| const uint8_t key3[LTC_DES_KEY_SIZE], |
| ltc_mode_symmetric_alg_t modeAs, |
| ltc_mode_encrypt_t modeEnc) |
| { |
| status_t retval; |
| uint8_t key[LTC_DES_KEY_SIZE * 3]; |
| uint8_t keySize = LTC_DES_KEY_SIZE * 2; |
| |
| retval = ltc_3des_check_input_args(modeAs, size, key1, key2); |
| if (kStatus_Success != retval) |
| { |
| if (handle->callback) |
| { |
| handle->callback(base, handle, kStatus_InvalidArgument, handle->userData); |
| } |
| return retval; |
| } |
| |
| ltc_memcpy(&key[0], &key1[0], LTC_DES_KEY_SIZE); |
| ltc_memcpy(&key[LTC_DES_KEY_SIZE], &key2[0], LTC_DES_KEY_SIZE); |
| if (key3) |
| { |
| ltc_memcpy(&key[LTC_DES_KEY_SIZE * 2], &key3[0], LTC_DES_KEY_SIZE); |
| keySize = sizeof(key); |
| } |
| |
| /* Initialize algorithm state. */ |
| ltc_symmetric_update(base, &key[0], keySize, kLTC_Algorithm3DES, modeAs, modeEnc); |
| |
| if ((modeAs != kLTC_ModeECB)) |
| { |
| ltc_set_context(base, iv, LTC_DES_IV_SIZE, 0); |
| } |
| |
| /* Process data and return status. */ |
| handle->inData = input; |
| handle->outData = output; |
| handle->size = size; |
| handle->state = LTC_SM_STATE_START; |
| handle->state_machine = ltc_process_message_in_sessions_EDMA; |
| retval = handle->state_machine(base, handle); |
| |
| return retval; |
| } |
| /******************************************************************************* |
| * DES / 3DES Code public |
| ******************************************************************************/ |
| status_t LTC_DES_EncryptEcbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *plaintext, |
| uint8_t *ciphertext, |
| uint32_t size, |
| const uint8_t key[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_des_process_EDMA(base, handle, plaintext, ciphertext, size, NULL, key, kLTC_ModeECB, kLTC_ModeEncrypt); |
| } |
| |
| status_t LTC_DES_DecryptEcbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *ciphertext, |
| uint8_t *plaintext, |
| uint32_t size, |
| const uint8_t key[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_des_process_EDMA(base, handle, ciphertext, plaintext, size, NULL, key, kLTC_ModeECB, kLTC_ModeDecrypt); |
| } |
| |
| status_t LTC_DES_EncryptCbcEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *plaintext, |
| uint8_t *ciphertext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_des_process_EDMA(base, handle, plaintext, ciphertext, size, iv, key, kLTC_ModeCBC, kLTC_ModeEncrypt); |
| } |
| |
| status_t LTC_DES_DecryptCbcEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *ciphertext, |
| uint8_t *plaintext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_des_process_EDMA(base, handle, ciphertext, plaintext, size, iv, key, kLTC_ModeCBC, kLTC_ModeDecrypt); |
| } |
| |
| status_t LTC_DES_EncryptCfbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *plaintext, |
| uint8_t *ciphertext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_des_process_EDMA(base, handle, plaintext, ciphertext, size, iv, key, kLTC_ModeCFB, kLTC_ModeEncrypt); |
| } |
| |
| status_t LTC_DES_DecryptCfbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *ciphertext, |
| uint8_t *plaintext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_des_process_EDMA(base, handle, ciphertext, plaintext, size, iv, key, kLTC_ModeCFB, kLTC_ModeDecrypt); |
| } |
| |
| status_t LTC_DES_EncryptOfbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *plaintext, |
| uint8_t *ciphertext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_des_process_EDMA(base, handle, plaintext, ciphertext, size, iv, key, kLTC_ModeOFB, kLTC_ModeEncrypt); |
| } |
| |
| status_t LTC_DES_DecryptOfbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *ciphertext, |
| uint8_t *plaintext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_des_process_EDMA(base, handle, ciphertext, plaintext, size, iv, key, kLTC_ModeOFB, kLTC_ModeDecrypt); |
| } |
| |
| status_t LTC_DES2_EncryptEcbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *plaintext, |
| uint8_t *ciphertext, |
| uint32_t size, |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_3des_process_EDMA(base, handle, plaintext, ciphertext, size, NULL, key1, key2, NULL, kLTC_ModeECB, |
| kLTC_ModeEncrypt); |
| } |
| |
| status_t LTC_DES3_EncryptEcbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *plaintext, |
| uint8_t *ciphertext, |
| uint32_t size, |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE], |
| const uint8_t key3[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_3des_process_EDMA(base, handle, plaintext, ciphertext, size, NULL, key1, key2, key3, kLTC_ModeECB, |
| kLTC_ModeEncrypt); |
| } |
| |
| status_t LTC_DES2_DecryptEcbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *ciphertext, |
| uint8_t *plaintext, |
| uint32_t size, |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_3des_process_EDMA(base, handle, ciphertext, plaintext, size, NULL, key1, key2, NULL, kLTC_ModeECB, |
| kLTC_ModeDecrypt); |
| } |
| |
| status_t LTC_DES3_DecryptEcbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *ciphertext, |
| uint8_t *plaintext, |
| uint32_t size, |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE], |
| const uint8_t key3[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_3des_process_EDMA(base, handle, ciphertext, plaintext, size, NULL, key1, key2, key3, kLTC_ModeECB, |
| kLTC_ModeDecrypt); |
| } |
| |
| status_t LTC_DES2_EncryptCbcEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *plaintext, |
| uint8_t *ciphertext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_3des_process_EDMA(base, handle, plaintext, ciphertext, size, iv, key1, key2, NULL, kLTC_ModeCBC, |
| kLTC_ModeEncrypt); |
| } |
| |
| status_t LTC_DES3_EncryptCbcEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *plaintext, |
| uint8_t *ciphertext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE], |
| const uint8_t key3[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_3des_process_EDMA(base, handle, plaintext, ciphertext, size, iv, key1, key2, key3, kLTC_ModeCBC, |
| kLTC_ModeEncrypt); |
| } |
| |
| status_t LTC_DES2_DecryptCbcEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *ciphertext, |
| uint8_t *plaintext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_3des_process_EDMA(base, handle, ciphertext, plaintext, size, iv, key1, key2, NULL, kLTC_ModeCBC, |
| kLTC_ModeDecrypt); |
| } |
| |
| status_t LTC_DES3_DecryptCbcEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *ciphertext, |
| uint8_t *plaintext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE], |
| const uint8_t key3[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_3des_process_EDMA(base, handle, ciphertext, plaintext, size, iv, key1, key2, key3, kLTC_ModeCBC, |
| kLTC_ModeDecrypt); |
| } |
| |
| status_t LTC_DES2_EncryptCfbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *plaintext, |
| uint8_t *ciphertext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_3des_process_EDMA(base, handle, plaintext, ciphertext, size, iv, key1, key2, NULL, kLTC_ModeCFB, |
| kLTC_ModeEncrypt); |
| } |
| |
| status_t LTC_DES3_EncryptCfbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *plaintext, |
| uint8_t *ciphertext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE], |
| const uint8_t key3[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_3des_process_EDMA(base, handle, plaintext, ciphertext, size, iv, key1, key2, key3, kLTC_ModeCFB, |
| kLTC_ModeEncrypt); |
| } |
| |
| status_t LTC_DES2_DecryptCfbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *ciphertext, |
| uint8_t *plaintext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_3des_process_EDMA(base, handle, ciphertext, plaintext, size, iv, key1, key2, NULL, kLTC_ModeCFB, |
| kLTC_ModeDecrypt); |
| } |
| |
| status_t LTC_DES3_DecryptCfbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *ciphertext, |
| uint8_t *plaintext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE], |
| const uint8_t key3[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_3des_process_EDMA(base, handle, ciphertext, plaintext, size, iv, key1, key2, key3, kLTC_ModeCFB, |
| kLTC_ModeDecrypt); |
| } |
| |
| status_t LTC_DES2_EncryptOfbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *plaintext, |
| uint8_t *ciphertext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_3des_process_EDMA(base, handle, plaintext, ciphertext, size, iv, key1, key2, NULL, kLTC_ModeOFB, |
| kLTC_ModeEncrypt); |
| } |
| |
| status_t LTC_DES3_EncryptOfbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *plaintext, |
| uint8_t *ciphertext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE], |
| const uint8_t key3[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_3des_process_EDMA(base, handle, plaintext, ciphertext, size, iv, key1, key2, key3, kLTC_ModeOFB, |
| kLTC_ModeEncrypt); |
| } |
| |
| status_t LTC_DES2_DecryptOfbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *ciphertext, |
| uint8_t *plaintext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_3des_process_EDMA(base, handle, ciphertext, plaintext, size, iv, key1, key2, NULL, kLTC_ModeOFB, |
| kLTC_ModeDecrypt); |
| } |
| |
| status_t LTC_DES3_DecryptOfbEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| const uint8_t *ciphertext, |
| uint8_t *plaintext, |
| uint32_t size, |
| const uint8_t iv[LTC_DES_IV_SIZE], |
| const uint8_t key1[LTC_DES_KEY_SIZE], |
| const uint8_t key2[LTC_DES_KEY_SIZE], |
| const uint8_t key3[LTC_DES_KEY_SIZE]) |
| { |
| return ltc_3des_process_EDMA(base, handle, ciphertext, plaintext, size, iv, key1, key2, key3, kLTC_ModeOFB, |
| kLTC_ModeDecrypt); |
| } |
| #endif /* FSL_FEATURE_LTC_HAS_DES */ |
| |
| /*********************** LTC EDMA tools ***************************************/ |
| |
| static uint32_t LTC_GetInstance(LTC_Type *base) |
| { |
| uint32_t instance = 0; |
| uint32_t i; |
| |
| for (i = 0; i < FSL_FEATURE_SOC_LTC_COUNT; i++) |
| { |
| if (s_ltcBase[instance] == base) |
| { |
| instance = i; |
| break; |
| } |
| } |
| return instance; |
| } |
| |
| /*! |
| * @brief Enable or disable LTC Input FIFO DMA request. |
| * |
| * This function enables or disables DMA request and done signals for Input FIFO. |
| * |
| * @param base LTC peripheral base address. |
| * @param enable True to enable, false to disable. |
| */ |
| static inline void LTC_EnableInputFifoDMA(LTC_Type *base, bool enable) |
| { |
| if (enable) |
| { |
| base->CTL |= LTC_CTL_IFE_MASK; |
| } |
| else |
| { |
| base->CTL &= ~LTC_CTL_IFE_MASK; |
| } |
| } |
| |
| /*! |
| * @brief Enable or disable LTC Output FIFO DMA request. |
| * |
| * This function enables or disables DMA request and done signals for Output FIFO. |
| * |
| * @param base LTC peripheral base address. |
| * @param enable True to enable, false to disable. |
| */ |
| static inline void LTC_EnableOutputFifoDMA(LTC_Type *base, bool enable) |
| { |
| if (enable) |
| { |
| base->CTL |= LTC_CTL_OFE_MASK; |
| } |
| else |
| { |
| base->CTL &= ~LTC_CTL_OFE_MASK; |
| } |
| } |
| |
| static void LTC_InputFifoEDMACallback(edma_handle_t *handle, void *param, bool transferDone, uint32_t tcds) |
| { |
| ltc_edma_private_handle_t *ltcPrivateHandle = (ltc_edma_private_handle_t *)param; |
| |
| /* Avoid the warning for unused variables. */ |
| handle = handle; |
| tcds = tcds; |
| |
| if (transferDone) |
| { |
| /* Stop DMA channel. */ |
| EDMA_StopTransfer(ltcPrivateHandle->handle->inputFifoEdmaHandle); |
| |
| /* Disable Input Fifo DMA */ |
| LTC_EnableInputFifoDMA(ltcPrivateHandle->base, false); |
| } |
| } |
| |
| static void LTC_OutputFifoEDMACallback(edma_handle_t *handle, void *param, bool transferDone, uint32_t tcds) |
| { |
| ltc_edma_private_handle_t *ltcPrivateHandle = (ltc_edma_private_handle_t *)param; |
| |
| /* Avoid the warning for unused variables. */ |
| handle = handle; |
| tcds = tcds; |
| |
| if (transferDone) |
| { |
| /* Stop DMA channel. */ |
| EDMA_StopTransfer(ltcPrivateHandle->handle->outputFifoEdmaHandle); |
| |
| /* Disable Output Fifo DMA */ |
| LTC_EnableOutputFifoDMA(ltcPrivateHandle->base, false); |
| |
| if (ltcPrivateHandle->handle->state_machine) |
| { |
| ltcPrivateHandle->handle->state_machine(ltcPrivateHandle->base, ltcPrivateHandle->handle); |
| } |
| } |
| } |
| |
| /* @brief Copy data to Input FIFO and reading from Ouput FIFO using eDMA. */ |
| static void ltc_symmetric_process_EDMA(LTC_Type *base, uint32_t inSize, const uint8_t **inData, uint8_t **outData) |
| { |
| const uint8_t *in = *inData; |
| uint8_t *out = *outData; |
| uint32_t instance = LTC_GetInstance(base); |
| uint32_t entry_number = inSize / sizeof(uint32_t); |
| const uint8_t *inputBuffer = *inData; |
| uint8_t *outputBuffer = *outData; |
| edma_transfer_config_t config; |
| |
| if (entry_number) |
| { |
| /* =========== Init Input FIFO DMA ======================*/ |
| memset(&config, 0, sizeof(config)); |
| |
| /* Prepare transfer. */ |
| EDMA_PrepareTransfer(&config, (void *)inputBuffer, 1, (void *)(&((base)->IFIFO)), 4U, 4U, entry_number * 4, |
| kEDMA_MemoryToPeripheral); |
| /* Submit transfer. */ |
| EDMA_SubmitTransfer(s_edmaPrivateHandle[instance].handle->inputFifoEdmaHandle, &config); |
| |
| /* Set request size.*/ |
| base->CTL &= ~LTC_CTL_IFR_MASK; /* 1 entry */ |
| /* Enable Input Fifo DMA */ |
| LTC_EnableInputFifoDMA(base, true); |
| |
| /* Start the DMA channel */ |
| EDMA_StartTransfer(s_edmaPrivateHandle[instance].handle->inputFifoEdmaHandle); |
| |
| /* =========== Init Output FIFO DMA ======================*/ |
| memset(&config, 0, sizeof(config)); |
| |
| /* Prepare transfer. */ |
| EDMA_PrepareTransfer(&config, (void *)(&((base)->OFIFO)), 4U, (void *)outputBuffer, 1U, 4U, entry_number * 4, |
| kEDMA_PeripheralToMemory); |
| /* Submit transfer. */ |
| EDMA_SubmitTransfer(s_edmaPrivateHandle[instance].handle->outputFifoEdmaHandle, &config); |
| |
| /* Set request size.*/ |
| base->CTL &= ~LTC_CTL_OFR_MASK; /* 1 entry */ |
| |
| /* Enable Output Fifo DMA */ |
| LTC_EnableOutputFifoDMA(base, true); |
| |
| /* Start the DMA channel */ |
| EDMA_StartTransfer(s_edmaPrivateHandle[instance].handle->outputFifoEdmaHandle); |
| |
| { /* Dummy read of LTC register. Do not delete.*/ |
| volatile uint32_t status_reg; |
| |
| status_reg = (base)->STA; |
| |
| (void)status_reg; |
| } |
| |
| out += entry_number * sizeof(uint32_t); |
| in += entry_number * sizeof(uint32_t); |
| |
| *inData = in; |
| *outData = out; |
| } |
| } |
| |
| void LTC_CreateHandleEDMA(LTC_Type *base, |
| ltc_edma_handle_t *handle, |
| ltc_edma_callback_t callback, |
| void *userData, |
| edma_handle_t *inputFifoEdmaHandle, |
| edma_handle_t *outputFifoEdmaHandle) |
| { |
| assert(handle); |
| assert(inputFifoEdmaHandle); |
| assert(outputFifoEdmaHandle); |
| |
| uint32_t instance = LTC_GetInstance(base); |
| |
| s_edmaPrivateHandle[instance].base = base; |
| s_edmaPrivateHandle[instance].handle = handle; |
| |
| memset(handle, 0, sizeof(*handle)); |
| |
| handle->inputFifoEdmaHandle = inputFifoEdmaHandle; |
| handle->outputFifoEdmaHandle = outputFifoEdmaHandle; |
| |
| handle->callback = callback; |
| handle->userData = userData; |
| |
| /* Register DMA callback functions */ |
| EDMA_SetCallback(handle->inputFifoEdmaHandle, LTC_InputFifoEDMACallback, &s_edmaPrivateHandle[instance]); |
| EDMA_SetCallback(handle->outputFifoEdmaHandle, LTC_OutputFifoEDMACallback, &s_edmaPrivateHandle[instance]); |
| |
| /* Set request size. DMA request size is 1 entry.*/ |
| base->CTL &= ~LTC_CTL_IFR_MASK; |
| base->CTL &= ~LTC_CTL_OFR_MASK; |
| } |
