diff --git a/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_aes_lld.c b/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_aes_lld.c
index da66978fc..bbe51ab20 100644
--- a/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_aes_lld.c
+++ b/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_aes_lld.c
@@ -112,6 +112,7 @@ cryerror_t sama_aes_lld_process_polling(CRYDriver *cryp, aesparams *params,
uint32_t i;
cryerror_t ret;
+ osalMutexLock(&cryp->mutex);
//AES soft reset
AES->AES_CR = AES_CR_SWRST;
@@ -125,11 +126,11 @@ cryerror_t sama_aes_lld_process_polling(CRYDriver *cryp, aesparams *params,
AES->AES_MR |= (AES_MR_CFBS(cryp->config->cfbs) | AES_MR_CKEY_PASSWD);
- osalMutexLock(&cryp->mutex);
+
sama_aes_lld_write_key(cryp->key0_buffer,( const uint32_t *) params->iv, cryp->key0_size);
- osalMutexUnlock(&cryp->mutex);
+
if (params->encrypt)
AES->AES_MR |= AES_MR_CIPHER;
@@ -156,6 +157,8 @@ cryerror_t sama_aes_lld_process_polling(CRYDriver *cryp, aesparams *params,
}
+ osalMutexUnlock(&cryp->mutex);
+
return CRY_NOERROR;
}
@@ -167,6 +170,8 @@ cryerror_t sama_aes_lld_process_dma(CRYDriver *cryp, aesparams *params,
osalDbgAssert(cryp->thread == NULL, "already waiting");
+ osalMutexLock(&cryp->mutex);
+
//set chunk size
cryp->dmachunksize = DMA_CHUNK_SIZE_4;
@@ -230,12 +235,8 @@ cryerror_t sama_aes_lld_process_dma(CRYDriver *cryp, aesparams *params,
AES->AES_MR |= (AES_MR_CFBS(cryp->config->cfbs) | AES_MR_CKEY_PASSWD);
- osalMutexLock(&cryp->mutex);
-
sama_aes_lld_write_key(cryp->key0_buffer,( const uint32_t *) params->iv, cryp->key0_size);
- osalMutexUnlock(&cryp->mutex);
-
if (params->encrypt)
AES->AES_MR |= AES_MR_CIPHER;
else
@@ -258,6 +259,8 @@ cryerror_t sama_aes_lld_process_dma(CRYDriver *cryp, aesparams *params,
osalSysUnlock();
+ osalMutexUnlock(&cryp->mutex);
+
return CRY_NOERROR;
}
diff --git a/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_crypto_lld.c b/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_crypto_lld.c
index f06ef34ed..12c2df965 100644
--- a/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_crypto_lld.c
+++ b/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_crypto_lld.c
@@ -133,8 +133,6 @@ static void crypto_lld_serve_read_interrupt(CRYDriver *cryp, uint32_t flags) {
#endif
/* Stop everything.*/
-
- dmaChannelDisable(cryp->dmatx);
dmaChannelDisable(cryp->dmarx);
/* Portable CRY ISR code defined in the high level driver, note, it is
a macro.*/
@@ -161,7 +159,10 @@ static void crypto_lld_serve_write_interrupt(CRYDriver *cryp, uint32_t flags) {
(void)flags;
#endif
+ dmaChannelDisable(cryp->dmatx);
+ if (cryp->rxdmamode == 0xFFFFFFFF)
+ _cry_isr_code(cryp);
}
#endif
diff --git a/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_sha_lld.c b/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_sha_lld.c
index 9806541fd..673fa6ffd 100644
--- a/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_sha_lld.c
+++ b/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_sha_lld.c
@@ -39,9 +39,9 @@ static uint32_t shadPaddedMessSize(uint8_t mode, uint32_t len);
uint8_t shaBlockSize(shadalgo_t algo);
static void loadData(const uint8_t* data, int len);
static void readData(const uint8_t* data, int len);
-static uint32_t processBlock(const uint8_t* data, uint32_t len, uint32_t block_size);
-static void updatePollingMode(CRYDriver *cryp,struct sha_data *shadata,const uint8_t* data, uint32_t data_size);
-static void updateDMA(CRYDriver *cryp,struct sha_data *shadata,const uint8_t* data, uint32_t data_size);
+static uint32_t processBlockPolling(CRYDriver *cryp, uint32_t len, uint32_t block_size);
+static uint32_t processBlockDMA(CRYDriver *cryp, uint32_t len, uint32_t block_size);
+static void update(CRYDriver *cryp,struct sha_data *shadata,const uint8_t* data, uint32_t data_size);
static uint32_t fillPadding(struct sha_data *shadata, uint32_t len, uint8_t* buffer);
@@ -90,7 +90,10 @@ int sha_finish(CRYDriver *cryp,struct sha_data *shadata,const uint8_t* buffer,ui
&cryp->sha_buffer[shadata->remaining]
);
- processBlock(cryp->sha_buffer, shadata->remaining + padding_len, shadata->block_size);
+ if (cryp->config->transfer_mode == TRANSFER_POLLING)
+ processBlockPolling(cryp, shadata->remaining + padding_len, shadata->block_size);
+ else
+ processBlockDMA(cryp, shadata->remaining + padding_len, shadata->block_size);
readData(buffer, buffer_size);
@@ -107,12 +110,13 @@ cryerror_t sama_sha_lld_process(CRYDriver *cryp,
uint32_t algoregval;
struct sha_data shadata;
-
if (!(cryp->enabledPer & SHA_PER)) {
- cryp->enabledPer |= SHA_PER;
- pmcEnableSHA();
+ cryp->enabledPer |= SHA_PER;
+ pmcEnableSHA();
}
+ osalMutexLock(&cryp->mutex);
+
shadata.processed = 0;
shadata.remaining = 0;
shadata.output_size = shaOutputSize(params->algo);
@@ -120,66 +124,86 @@ cryerror_t sama_sha_lld_process(CRYDriver *cryp,
shadata.algo = params->algo;
if (shadata.output_size == 0) {
- return CRY_ERR_INV_ALGO;
+ return CRY_ERR_INV_ALGO;
}
switch (params->algo) {
- case CRY_SHA_1:
- algoregval = SHA_MR_ALGO_SHA1;
- break;
- case CRY_SHA_224:
- algoregval = SHA_MR_ALGO_SHA224;
- break;
- case CRY_SHA_256:
- algoregval = SHA_MR_ALGO_SHA256;
- break;
- #ifdef SHA_MR_ALGO_SHA384
- case CRY_SHA_384:
- algoregval = SHA_MR_ALGO_SHA384;
- break;
- #endif
- #ifdef SHA_MR_ALGO_SHA512
- case CRY_SHA_512:
- algoregval = SHA_MR_ALGO_SHA512;
- break;
- #endif
- default:
- return CRY_ERR_INV_ALGO;
- }
+ case CRY_SHA_1:
+ algoregval = SHA_MR_ALGO_SHA1;
+ break;
+ case CRY_SHA_224:
+ algoregval = SHA_MR_ALGO_SHA224;
+ break;
+ case CRY_SHA_256:
+ algoregval = SHA_MR_ALGO_SHA256;
+ break;
+#ifdef SHA_MR_ALGO_SHA384
+ case CRY_SHA_384:
+ algoregval = SHA_MR_ALGO_SHA384;
+ break;
+#endif
+#ifdef SHA_MR_ALGO_SHA512
+ case CRY_SHA_512:
+ algoregval = SHA_MR_ALGO_SHA512;
+ break;
+#endif
+ default:
+ return CRY_ERR_INV_ALGO;
+ }
//soft reset
SHA->SHA_CR = SHA_CR_SWRST;
+ if (cryp->config->transfer_mode == TRANSFER_POLLING) {
+ algoregval |= SHA_MR_SMOD_MANUAL_START;
+ } else {
+ algoregval |= SHA_MR_SMOD_IDATAR0_START;
+
+ cryp->dmawith = DMA_DATA_WIDTH_WORD;
+ cryp->dmachunksize = DMA_CHUNK_SIZE_16;
+
+ cryp->txdmamode = XDMAC_CC_TYPE_PER_TRAN |
+ XDMAC_CC_PROT_SEC |
+ XDMAC_CC_MBSIZE_SINGLE |
+ XDMAC_CC_DSYNC_MEM2PER | XDMAC_CC_CSIZE(cryp->dmachunksize) |
+ XDMAC_CC_DWIDTH(cryp->dmawith) |
+ XDMAC_CC_SIF_AHB_IF0 |
+ XDMAC_CC_DIF_AHB_IF1 |
+ XDMAC_CC_SAM_INCREMENTED_AM |
+ XDMAC_CC_DAM_FIXED_AM |
+ XDMAC_CC_PERID(PERID_SHA_TX);
+
+ cryp->rxdmamode = 0xFFFFFFFF;
+
+ dmaChannelSetMode(cryp->dmatx, cryp->txdmamode);
+ }
//configure
- SHA->SHA_MR = algoregval | SHA_MR_SMOD_MANUAL_START | SHA_MR_PROCDLY_LONGEST;
+ SHA->SHA_MR = algoregval | SHA_MR_PROCDLY_LONGEST;
//enable interrupt
SHA->SHA_IER = SHA_IER_DATRDY;
uint32_t buf_in_size;
- const uint8_t *p=in;
+ const uint8_t *p = in;
while (indata_len) {
- buf_in_size = min_u32(indata_len, SHA_UPDATE_LEN);
+ buf_in_size = min_u32(indata_len, SHA_UPDATE_LEN);
- //First block
- if (!shadata.processed) {
- SHA->SHA_CR = SHA_CR_FIRST;
- }
+ //First block
+ if (!shadata.processed) {
+ SHA->SHA_CR = SHA_CR_FIRST;
+ }
- if (cryp->config->transfer_mode == TRANSFER_POLLING)
- updatePollingMode(cryp,&shadata, in, buf_in_size);
- else
- updateDMA(cryp,&shadata, in, buf_in_size);
+ update(cryp, &shadata, in, buf_in_size);
- p += buf_in_size;
- indata_len -= buf_in_size;
+ p += buf_in_size;
+ indata_len -= buf_in_size;
}
- sha_finish(cryp, &shadata,out, shadata.output_size);
-
+ sha_finish(cryp, &shadata, out, shadata.output_size);
+ osalMutexUnlock(&cryp->mutex);
return CRY_NOERROR;
}
@@ -258,14 +282,14 @@ static void readData(const uint8_t* data, int len)
}
-static uint32_t processBlock(const uint8_t* data, uint32_t len, uint32_t block_size)
+static uint32_t processBlockPolling(CRYDriver *cryp,uint32_t len, uint32_t block_size)
{
uint32_t processed = 0;
while ((len - processed) >= block_size) {
// load data in the sha input registers
- loadData(&data[processed], block_size);
+ loadData(&cryp->sha_buffer[processed], block_size);
SHA->SHA_CR = SHA_CR_START;
@@ -278,14 +302,34 @@ static uint32_t processBlock(const uint8_t* data, uint32_t len, uint32_t block_s
return processed;
}
-static void updateDMA(CRYDriver *cryp,struct sha_data *shadata,const uint8_t* data, uint32_t data_size)
+static uint32_t processBlockDMA(CRYDriver *cryp, uint32_t len, uint32_t block_size)
{
- (void)shadata;
- (void)data;
- (void)data_size;
- (void)cryp;
+ uint32_t processed = 0;
+
+ while ((len - processed) >= block_size) {
+
+ // load data in the sha input registers
+ // Writing channel
+ dmaChannelSetSource(cryp->dmatx, &cryp->sha_buffer[processed]);
+ dmaChannelSetDestination(cryp->dmatx, SHA->SHA_IDATAR);
+ dmaChannelSetTransactionSize(cryp->dmatx,
+ (block_size / DMA_DATA_WIDTH_TO_BYTE(cryp->dmawith)));
+
+ osalSysLock();
+
+ dmaChannelEnable(cryp->dmatx);
+
+ osalThreadSuspendS(&cryp->thread);
+
+ osalSysUnlock();
+
+ processed += block_size;
+ }
+
+ return processed;
}
-static void updatePollingMode(CRYDriver *cryp,struct sha_data *shadata,const uint8_t* data, uint32_t data_size)
+
+static void update(CRYDriver *cryp,struct sha_data *shadata,const uint8_t* data, uint32_t data_size)
{
uint32_t i;
uint32_t processed;
@@ -301,7 +345,10 @@ static void updatePollingMode(CRYDriver *cryp,struct sha_data *shadata,const uin
//if data is complete process the block
if (shadata->remaining == shadata->block_size) {
- processBlock(cryp->sha_buffer, shadata->remaining, shadata->block_size);
+ if (cryp->config->transfer_mode == TRANSFER_POLLING )
+ processBlockPolling(cryp,shadata->remaining, shadata->block_size);
+ else
+ processBlockDMA(cryp, shadata->remaining, shadata->block_size);
shadata->processed += shadata->block_size;
shadata->remaining = 0;
@@ -312,7 +359,11 @@ static void updatePollingMode(CRYDriver *cryp,struct sha_data *shadata,const uin
}
// Process blocks
- processed = processBlock(data, data_size, shadata->block_size);
+ if (cryp->config->transfer_mode == TRANSFER_POLLING )
+ processed = processBlockPolling(cryp, data_size, shadata->block_size);
+ else
+ processed = processBlockDMA(cryp, data_size, shadata->block_size);
+
shadata->processed += processed;
//check remaining data and process
diff --git a/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_tdes_lld.c b/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_tdes_lld.c
index a2dcd5cd3..76ff34145 100644
--- a/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_tdes_lld.c
+++ b/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_tdes_lld.c
@@ -44,6 +44,9 @@ cryerror_t sama_tdes_lld_polling(CRYDriver *cryp, tdes_config_t *params,
uint32_t i;
uint8_t size = 8;
uint32_t *vectors = (uint32_t *) iv;
+
+ osalMutexLock(&cryp->mutex);
+
//soft reset
TDES->TDES_CR = TDES_CR_SWRST;
//configure
@@ -78,7 +81,7 @@ cryerror_t sama_tdes_lld_polling(CRYDriver *cryp, tdes_config_t *params,
}
TDES->TDES_MR = mode;
- osalMutexLock(&cryp->mutex);
+
//write keys
TDES->TDES_KEY1WR[0] = cryp->key0_buffer[0];
@@ -106,7 +109,7 @@ cryerror_t sama_tdes_lld_polling(CRYDriver *cryp, tdes_config_t *params,
if (params->algo == TDES_ALGO_XTEA) {
TDES->TDES_XTEA_RNDR = TDES_XTEA_RNDR_XTEA_RNDS(32);
}
- osalMutexUnlock(&cryp->mutex);
+
//load 64 bit data size in tdes registers
for (i = 0; i < data_len; i += size) {
if (size == 8)
@@ -129,6 +132,9 @@ cryerror_t sama_tdes_lld_polling(CRYDriver *cryp, tdes_config_t *params,
tdes_get_output((uint32_t *) ((out) + i), NULL);
}
+ osalMutexUnlock(&cryp->mutex);
+
+
return CRY_NOERROR;
}
@@ -139,6 +145,8 @@ cryerror_t sama_tdes_lld_dma(CRYDriver *cryp, tdes_config_t *params,
uint32_t mode = 0;
uint32_t *vectors = (uint32_t *) iv;
+ osalMutexLock(&cryp->mutex);
+
cryp->dmachunksize = DMA_CHUNK_SIZE_1;
cryp->dmawith = DMA_DATA_WIDTH_WORD;
@@ -214,7 +222,7 @@ cryerror_t sama_tdes_lld_dma(CRYDriver *cryp, tdes_config_t *params,
TDES->TDES_MR = mode;
- osalMutexLock(&cryp->mutex);
+
//write keys
TDES->TDES_KEY1WR[0] = cryp->key0_buffer[0];
@@ -240,7 +248,7 @@ cryerror_t sama_tdes_lld_dma(CRYDriver *cryp, tdes_config_t *params,
TDES->TDES_IVR[1] = vectors[1];
}
- osalMutexUnlock(&cryp->mutex);
+
if (params->algo == TDES_ALGO_XTEA) {
TDES->TDES_XTEA_RNDR = TDES_XTEA_RNDR_XTEA_RNDS(32);
@@ -257,6 +265,8 @@ cryerror_t sama_tdes_lld_dma(CRYDriver *cryp, tdes_config_t *params,
osalThreadSuspendS(&cryp->thread);
osalSysUnlock();
+ osalMutexUnlock(&cryp->mutex);
+
return CRY_NOERROR;
}
diff --git a/test/crypto/configuration.xml b/test/crypto/configuration.xml
index 4d5edd304..1970465fe 100644
--- a/test/crypto/configuration.xml
+++ b/test/crypto/configuration.xml
@@ -2677,6 +2677,285 @@ for (int i = 0; i < 16; i++) {
+
+
+
+ Internal Tests
+
+
+ SHA
+
+
+ SHA testing
+
+
+
+
+
+
+#include "ref_sha.h"
+
+#define MAX_DIGEST_SIZE_INBYTE 64
+#define MAX_DIGEST_SIZE_INWORD (MAX_DIGEST_SIZE_INBYTE/4)
+static uint32_t digest[MAX_DIGEST_SIZE_INWORD];
+
+static const CRYConfig configSHA_DMA=
+{
+ TRANSFER_DMA,
+ 0,
+ 0
+};
+
+ ]]>
+
+
+
+
+ SHA1 DMA
+
+
+ testing SHA1 in DMA mode
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Digest
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ SHA256 DMA
+
+
+ testing SHA256 in DMA mode
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Digest
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ SHA512 DMA
+
+
+ testing SHA512 in DMA mode
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Digest
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/test/crypto/crypto_test.mk b/test/crypto/crypto_test.mk
index efd7faf88..0d7310271 100644
--- a/test/crypto/crypto_test.mk
+++ b/test/crypto/crypto_test.mk
@@ -8,7 +8,8 @@ TESTSRC += ${CHIBIOS}/test/crypto/source/test/cry_test_root.c \
${CHIBIOS}/test/crypto/source/test/cry_test_sequence_003.c \
${CHIBIOS}/test/crypto/source/test/cry_test_sequence_004.c \
${CHIBIOS}/test/crypto/source/test/cry_test_sequence_005.c \
- ${CHIBIOS}/test/crypto/source/test/cry_test_sequence_006.c
+ ${CHIBIOS}/test/crypto/source/test/cry_test_sequence_006.c \
+ ${CHIBIOS}/test/crypto/source/test/cry_test_sequence_007.c
# Required include directories
TESTINC += ${CHIBIOS}/test/crypto/source/testref \
${CHIBIOS}/test/crypto/source/test
diff --git a/test/crypto/source/test/cry_test_root.c b/test/crypto/source/test/cry_test_root.c
index bd176b409..77d07a822 100644
--- a/test/crypto/source/test/cry_test_root.c
+++ b/test/crypto/source/test/cry_test_root.c
@@ -27,6 +27,7 @@
* - @subpage cry_test_sequence_004
* - @subpage cry_test_sequence_005
* - @subpage cry_test_sequence_006
+ * - @subpage cry_test_sequence_007
* .
*/
@@ -54,6 +55,7 @@ const testsequence_t * const cry_test_suite_array[] = {
&cry_test_sequence_004,
&cry_test_sequence_005,
&cry_test_sequence_006,
+ &cry_test_sequence_007,
NULL
};
diff --git a/test/crypto/source/test/cry_test_root.h b/test/crypto/source/test/cry_test_root.h
index 24842646f..18fa28074 100644
--- a/test/crypto/source/test/cry_test_root.h
+++ b/test/crypto/source/test/cry_test_root.h
@@ -30,6 +30,7 @@
#include "cry_test_sequence_004.h"
#include "cry_test_sequence_005.h"
#include "cry_test_sequence_006.h"
+#include "cry_test_sequence_007.h"
#if !defined(__DOXYGEN__)
diff --git a/test/crypto/source/test/cry_test_sequence_007.c b/test/crypto/source/test/cry_test_sequence_007.c
new file mode 100644
index 000000000..af114650f
--- /dev/null
+++ b/test/crypto/source/test/cry_test_sequence_007.c
@@ -0,0 +1,295 @@
+/*
+ ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio
+
+ 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.
+*/
+
+#include "hal.h"
+#include "cry_test_root.h"
+
+/**
+ * @file cry_test_sequence_007.c
+ * @brief Test Sequence 007 code.
+ *
+ * @page cry_test_sequence_007 [7] SHA
+ *
+ * File: @ref cry_test_sequence_007.c
+ *
+ * Description
+ * SHA testing.
+ *
+ * Test Cases
+ * - @subpage cry_test_007_001
+ * - @subpage cry_test_007_002
+ * - @subpage cry_test_007_003
+ * .
+ */
+
+/****************************************************************************
+ * Shared code.
+ ****************************************************************************/
+
+#include
+#include "ref_sha.h"
+
+#define MAX_DIGEST_SIZE_INBYTE 64
+#define MAX_DIGEST_SIZE_INWORD (MAX_DIGEST_SIZE_INBYTE/4)
+static uint32_t digest[MAX_DIGEST_SIZE_INWORD];
+
+static const CRYConfig configSHA_DMA=
+{
+ TRANSFER_DMA,
+ 0,
+ 0
+};
+
+
+
+/****************************************************************************
+ * Test cases.
+ ****************************************************************************/
+
+/**
+ * @page cry_test_007_001 [7.1] SHA1 DMA
+ *
+ * Description
+ * testing SHA1 in DMA mode.
+ *
+ * Test Steps
+ * - [7.1.1] Digest.
+ * .
+ */
+
+static void cry_test_007_001_setup(void) {
+ memset(msg_clear, 0, TEST_MSG_DATA_BYTE_LEN);
+ memset(digest, 0, MAX_DIGEST_SIZE_INWORD);
+ memcpy((char*) msg_clear, sha_msg0, SHA_LEN_0);
+ cryStart(&CRYD1, &configSHA_DMA);
+
+
+}
+
+static void cry_test_007_001_teardown(void) {
+ cryStop(&CRYD1);
+}
+
+static void cry_test_007_001_execute(void) {
+ cryerror_t ret;
+ uint32_t *ref;
+
+ /* [7.1.1] Digest.*/
+ test_set_step(1);
+ {
+ //---- One Block Test
+ ret = crySHA1(&CRYD1,SHA_LEN_0,(uint8_t*)msg_clear,(uint8_t*)digest);
+
+
+ test_assert(ret == CRY_NOERROR, "sha1 failed");
+
+
+ SHOW_DATA(digest,5);
+
+ ref = (uint32_t*)refSHA_SHA1_3;
+ for (int i = 0; i < 5; i++) {
+ test_assert(digest[i] == ref[i], "sha1 digest mismatch");
+ }
+
+ //---- Multi Block Test
+ memset(msg_clear, 0, TEST_MSG_DATA_BYTE_LEN);
+ memcpy((char*) msg_clear, sha_msg1, SHA_LEN_1);
+
+ ret = crySHA1(&CRYD1,SHA_LEN_1,(uint8_t*)msg_clear,(uint8_t*)digest);
+
+ test_assert(ret == CRY_NOERROR, "sha1 failed");
+
+ SHOW_DATA(digest,5);
+
+
+ ref = (uint32_t*)refSHA_SHA1_56;
+ for (int i = 0; i < 5; i++) {
+ test_assert(digest[i] == ref[i], "sha1 digest mismatch");
+ }
+
+
+ }
+}
+
+static const testcase_t cry_test_007_001 = {
+ "SHA1 DMA",
+ cry_test_007_001_setup,
+ cry_test_007_001_teardown,
+ cry_test_007_001_execute
+};
+
+/**
+ * @page cry_test_007_002 [7.2] SHA256 DMA
+ *
+ * Description
+ * testing SHA256 in DMA mode.
+ *
+ * Test Steps
+ * - [7.2.1] Digest.
+ * .
+ */
+
+static void cry_test_007_002_setup(void) {
+ memset(msg_clear, 0, TEST_MSG_DATA_BYTE_LEN);
+ memset(digest, 0, MAX_DIGEST_SIZE_INWORD);
+ memcpy((char*) msg_clear, sha_msg0, SHA_LEN_0);
+ cryStart(&CRYD1, &configSHA_DMA);
+
+
+}
+
+static void cry_test_007_002_teardown(void) {
+ cryStop(&CRYD1);
+}
+
+static void cry_test_007_002_execute(void) {
+ cryerror_t ret;
+ uint32_t *ref;
+
+ /* [7.2.1] Digest.*/
+ test_set_step(1);
+ {
+
+ //---- One Block Test
+ ret = crySHA256(&CRYD1,SHA_LEN_0,(uint8_t*)msg_clear,(uint8_t*)digest);
+
+ test_assert(ret == CRY_NOERROR, "sha256 failed");
+
+ SHOW_DATA(digest,8);
+
+ ref = (uint32_t*)refSHA_SHA256_3;
+ for (int i = 0; i < 8; i++) {
+ test_assert(digest[i] == ref[i], "sha256 digest mismatch");
+ }
+
+ //---- Multi Block Test
+ memset(msg_clear, 0, TEST_MSG_DATA_BYTE_LEN);
+ memcpy((char*) msg_clear, sha_msg1, SHA_LEN_1);
+
+ ret = crySHA256(&CRYD1,SHA_LEN_1,(uint8_t*)msg_clear,(uint8_t*)digest);
+
+ test_assert(ret == CRY_NOERROR, "sha256 failed");
+
+
+ SHOW_DATA(digest,8);
+
+ ref = (uint32_t*)refSHA_SHA256_56;
+ for (int i = 0; i < 8; i++) {
+ test_assert(digest[i] == ref[i], "sha256 digest mismatch");
+ }
+
+
+ }
+}
+
+static const testcase_t cry_test_007_002 = {
+ "SHA256 DMA",
+ cry_test_007_002_setup,
+ cry_test_007_002_teardown,
+ cry_test_007_002_execute
+};
+
+/**
+ * @page cry_test_007_003 [7.3] SHA512 DMA
+ *
+ * Description
+ * testing SHA512 in DMA mode.
+ *
+ * Test Steps
+ * - [7.3.1] Digest.
+ * .
+ */
+
+static void cry_test_007_003_setup(void) {
+ memset(msg_clear, 0, TEST_MSG_DATA_BYTE_LEN);
+ memset(digest, 0, MAX_DIGEST_SIZE_INWORD);
+ memcpy((char*) msg_clear, sha_msg0, SHA_LEN_0);
+ cryStart(&CRYD1, &configSHA_DMA);
+
+
+}
+
+static void cry_test_007_003_teardown(void) {
+ cryStop(&CRYD1);
+}
+
+static void cry_test_007_003_execute(void) {
+ cryerror_t ret;
+ uint32_t *ref;
+
+ /* [7.3.1] Digest.*/
+ test_set_step(1);
+ {
+ //---- One Block Test
+ ret = crySHA512(&CRYD1,SHA_LEN_0,(uint8_t*)msg_clear,(uint8_t*)digest);
+
+ test_assert(ret == CRY_NOERROR, "sha512 failed");
+
+ SHOW_DATA(digest,16);
+
+ ref = (uint32_t*)refSHA_SHA512_3;
+ for (int i = 0; i < 16; i++) {
+ test_assert(digest[i] == ref[i], "sha512 digest mismatch");
+ }
+
+ //---- Multi Block Test
+ memset(msg_clear, 0, TEST_MSG_DATA_BYTE_LEN);
+ memcpy((char*) msg_clear, sha_msg1, SHA_LEN_1);
+
+ ret = crySHA512(&CRYD1,SHA_LEN_1,(uint8_t*)msg_clear,(uint8_t*)digest);
+
+ test_assert(ret == CRY_NOERROR, "sha512 failed");
+
+
+ SHOW_DATA(digest,16);
+
+ ref = (uint32_t*)refSHA_SHA512_56;
+ for (int i = 0; i < 16; i++) {
+ test_assert(digest[i] == ref[i], "sha512 digest mismatch");
+ }
+
+
+ }
+}
+
+static const testcase_t cry_test_007_003 = {
+ "SHA512 DMA",
+ cry_test_007_003_setup,
+ cry_test_007_003_teardown,
+ cry_test_007_003_execute
+};
+
+/****************************************************************************
+ * Exported data.
+ ****************************************************************************/
+
+/**
+ * @brief Array of test cases.
+ */
+const testcase_t * const cry_test_sequence_007_array[] = {
+ &cry_test_007_001,
+ &cry_test_007_002,
+ &cry_test_007_003,
+ NULL
+};
+
+/**
+ * @brief SHA.
+ */
+const testsequence_t cry_test_sequence_007 = {
+ "SHA",
+ cry_test_sequence_007_array
+};
diff --git a/test/crypto/source/test/cry_test_sequence_007.h b/test/crypto/source/test/cry_test_sequence_007.h
new file mode 100644
index 000000000..fc8471cc3
--- /dev/null
+++ b/test/crypto/source/test/cry_test_sequence_007.h
@@ -0,0 +1,27 @@
+/*
+ ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio
+
+ 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.
+*/
+
+/**
+ * @file cry_test_sequence_007.h
+ * @brief Test Sequence 007 header.
+ */
+
+#ifndef CRY_TEST_SEQUENCE_007_H
+#define CRY_TEST_SEQUENCE_007_H
+
+extern const testsequence_t cry_test_sequence_007;
+
+#endif /* CRY_TEST_SEQUENCE_007_H */