added SHA in dma mode

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@11115 35acf78f-673a-0410-8e92-d51de3d6d3f4

10 files changed, 738 insertions, 68 deletions

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++) {
       </cases>
           </sequence>
 
+
+<sequence>
+            <type index="0">
+              <value>Internal Tests</value>
+            </type>
+            <brief>
+              <value>SHA</value>
+            </brief>
+            <description>
+              <value>SHA testing</value>
+            </description>
+            <condition>
+              <value />
+            </condition>
+            <shared_code>
+              <value><![CDATA[
+#include <string.h>
+#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
+};
+
+                ]]></value>
+            </shared_code>
+            <cases>
+       <case>
+                <brief>
+                  <value>SHA1 DMA</value>
+                </brief>
+                <description>
+                  <value>testing SHA1 in DMA mode</value>
+                </description>
+                <condition>
+                  <value />
+                </condition>
+                <various_code>
+                  <setup_code>
+                    <value><![CDATA[
+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);
+
+                      ]]></value>
+                  </setup_code>
+                  <teardown_code>
+                    <value><![CDATA[cryStop(&CRYD1);]]></value>
+                  </teardown_code>
+                  <local_variables>
+                    <value><![CDATA[
+  cryerror_t ret;
+  uint32_t *ref;
+]]></value>
+                  </local_variables>
+                </various_code>
+                <steps>
+                 
+                   <step>
+                    <description>
+                      <value>Digest</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+//---- 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");
+}
+
+
+]]></value>
+                    </code>
+                  </step>
+                  
+                
+
+                 
+ 
+                </steps>
+              </case>
+              
+   <case>
+                <brief>
+                  <value>SHA256 DMA</value>
+                </brief>
+                <description>
+                  <value>testing SHA256 in DMA mode</value>
+                </description>
+                <condition>
+                  <value />
+                </condition>
+                <various_code>
+                  <setup_code>
+                    <value><![CDATA[
+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);
+
+                      ]]></value>
+                  </setup_code>
+                  <teardown_code>
+                    <value><![CDATA[cryStop(&CRYD1);]]></value>
+                  </teardown_code>
+                  <local_variables>
+                    <value><![CDATA[
+  cryerror_t ret;
+  uint32_t *ref;
+]]></value>
+                  </local_variables>
+                </various_code>
+                <steps>
+                 
+                   <step>
+                    <description>
+                      <value>Digest</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+
+//---- 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");
+}
+
+
+]]></value>
+                    </code>
+                  </step>
+                  
+                
+
+                 
+ 
+                </steps>
+              </case>           
+ <case>
+                <brief>
+                  <value>SHA512 DMA</value>
+                </brief>
+                <description>
+                  <value>testing SHA512 in DMA mode</value>
+                </description>
+                <condition>
+                  <value />
+                </condition>
+                <various_code>
+                  <setup_code>
+                    <value><![CDATA[
+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);
+
+                      ]]></value>
+                  </setup_code>
+                  <teardown_code>
+                    <value><![CDATA[cryStop(&CRYD1);]]></value>
+                  </teardown_code>
+                  <local_variables>
+                    <value><![CDATA[
+  cryerror_t ret;
+  uint32_t *ref;
+]]></value>
+                  </local_variables>
+                </various_code>
+                <steps>
+                 
+                   <step>
+                    <description>
+                      <value>Digest</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+//---- 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");
+}
+
+
+]]></value>
+                    </code>
+                  </step>
+                  
+                
+
+                 
+ 
+                </steps>
+              </case>   
+      </cases>
+          </sequence>
         </sequences>
       </instance>
     </instances>
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

+ *

+ * <h2>Description</h2>

+ * SHA testing.

+ *

+ * <h2>Test Cases</h2>

+ * - @subpage cry_test_007_001

+ * - @subpage cry_test_007_002

+ * - @subpage cry_test_007_003

+ * .

+ */

+

+/****************************************************************************

+ * Shared code.

+ ****************************************************************************/

+

+#include <string.h>

+#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

+ *

+ * <h2>Description</h2>

+ * testing SHA1 in DMA mode.

+ *

+ * <h2>Test Steps</h2>

+ * - [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

+ *

+ * <h2>Description</h2>

+ * testing SHA256 in DMA mode.

+ *

+ * <h2>Test Steps</h2>

+ * - [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

+ *

+ * <h2>Description</h2>

+ * testing SHA512 in DMA mode.

+ *

+ * <h2>Test Steps</h2>

+ * - [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 */