Modify HW accelerator drivers to new error code

Ron Eldor · Ron Eldor · commit 9f4e752ef3f8 · 2018-11-11T09:59:18.000+02:00
Have the HW accelearation drivers return the platform module
errors about feature unsupported, and hw acceleration failure,
because the moduel specific errors will be removed.
diff --git a/features/cryptocell/FEATURE_CRYPTOCELL310/cc_internal.c b/features/cryptocell/FEATURE_CRYPTOCELL310/cc_internal.c
@@ -24,6 +24,7 @@
 #include "cc_internal.h"
 #include "crys_ecpki_error.h"
 #include "crys_ec_mont_edw_error.h"
+#include "mbedtls/platform.h"
 
 CRYS_ECPKI_DomainID_t convert_mbedtls_grp_id_to_crys_domain_id( mbedtls_ecp_group_id grp_id )
 {
@@ -135,7 +136,7 @@ int convert_CrysError_to_mbedtls_err( CRYSError_t Crys_err )
 
     case CRYS_ECMONT_IS_NOT_SUPPORTED:
     case CRYS_ECEDW_IS_NOT_SUPPORTED:
-        return ( MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE );
+        return ( MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED );
 
     case CRYS_ECEDW_RND_GEN_VECTOR_FUNC_ERROR:
         return ( MBEDTLS_ERR_ECP_RANDOM_FAILED );
@@ -146,7 +147,7 @@ int convert_CrysError_to_mbedtls_err( CRYSError_t Crys_err )
         return ( MBEDTLS_ERR_ECP_INVALID_KEY );
 
     default:
-        return ( MBEDTLS_ERR_ECP_HW_ACCEL_FAILED );
+        return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
     }
 
 
diff --git a/features/cryptocell/FEATURE_CRYPTOCELL310/cc_internal.h b/features/cryptocell/FEATURE_CRYPTOCELL310/cc_internal.h
@@ -122,7 +122,7 @@ uint32_t convert_mbedtls_to_cc_rand( void* mbedtls_rand, uint16_t outSizeBytes,
  *
  *
  * \return     \c The corresponding Mbed TLS error,
- *                MBEDTLS_ERR_ECP_HW_ACCEL_FAILED as default, if none found
+ *                MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED as default, if none found
  */
 int convert_CrysError_to_mbedtls_err( CRYSError_t Crys_err );
 
diff --git a/features/cryptocell/FEATURE_CRYPTOCELL310/ccm_alt.c b/features/cryptocell/FEATURE_CRYPTOCELL310/ccm_alt.c
@@ -51,7 +51,7 @@ int mbedtls_ccm_setkey( mbedtls_ccm_context *ctx,
     if( cipher != MBEDTLS_CIPHER_ID_AES ||
          keybits != 128 )
     {
-        return ( MBEDTLS_ERR_AES_FEATURE_UNAVAILABLE );
+        return ( MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED );
     }
 
     memcpy( ctx->cipher_key , key, keybits / 8 );
@@ -93,7 +93,7 @@ int mbedtls_ccm_encrypt_and_tag( mbedtls_ccm_context *ctx, size_t length,
     CrysRet =  CRYS_AESCCM( SASI_AES_ENCRYPT, ctx->cipher_key, ctx->keySize_ID,(uint8_t*)iv, iv_len,
                             (uint8_t*)add, add_len,  (uint8_t*)input, length, output, tag_len, tag );
     if( CrysRet != CRYS_OK )
-        return ( MBEDTLS_ERR_CCM_HW_ACCEL_FAILED );
+        return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
 
     return ( 0 );
 
@@ -130,7 +130,7 @@ int mbedtls_ccm_auth_decrypt( mbedtls_ccm_context *ctx, size_t length,
     CrysRet =  CRYS_AESCCM( SASI_AES_DECRYPT, ctx->cipher_key, ctx->keySize_ID,(uint8_t*)iv, iv_len,
                             (uint8_t*)add, add_len,  (uint8_t*)input, length, output, tag_len, (uint8_t*)tag );
     if ( CrysRet != CRYS_OK )
-        return ( MBEDTLS_ERR_CCM_HW_ACCEL_FAILED );
+        return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
 
     return ( 0 );
 
diff --git a/features/cryptocell/FEATURE_CRYPTOCELL310/ecdh_alt.c b/features/cryptocell/FEATURE_CRYPTOCELL310/ecdh_alt.c
@@ -118,7 +118,7 @@ int mbedtls_ecdh_gen_public( mbedtls_ecp_group *grp, mbedtls_mpi *d, mbedtls_ecp
           MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &Q->Z, 1 ) );
       }
       else
-          ret =  MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;
+          ret =  MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED;
 
 cleanup:
 
@@ -231,7 +231,7 @@ int mbedtls_ecdh_compute_shared( mbedtls_ecp_group *grp, mbedtls_mpi *z,
     }
     else
     {
-        ret =  MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;
+        ret =  MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED;
         goto cleanup;
     }
 
diff --git a/features/cryptocell/FEATURE_CRYPTOCELL310/ecdsa_alt.c b/features/cryptocell/FEATURE_CRYPTOCELL310/ecdsa_alt.c
@@ -132,7 +132,7 @@ int mbedtls_ecdsa_sign( mbedtls_ecp_group *grp, mbedtls_mpi *r, mbedtls_mpi *s,
     }
     else
     {
-        ret =  MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;
+        ret =  MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED;
         goto cleanup;
     }
 
@@ -226,7 +226,7 @@ int mbedtls_ecdsa_verify( mbedtls_ecp_group *grp,
         }
     }
     else
-        ret =  MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;
+        ret =  MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED;
 
 cleanup:
 
@@ -313,7 +313,7 @@ int mbedtls_ecdsa_genkey( mbedtls_ecdsa_context *ctx, mbedtls_ecp_group_id gid,
         }
     }
     else
-        ret =  MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;
+        ret =  MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED;
 
 
 cleanup:
diff --git a/features/cryptocell/FEATURE_CRYPTOCELL310/sha1_alt.c b/features/cryptocell/FEATURE_CRYPTOCELL310/sha1_alt.c
@@ -47,7 +47,7 @@ void mbedtls_sha1_clone( mbedtls_sha1_context *dst,
 int mbedtls_sha1_starts_ret( mbedtls_sha1_context *ctx )
 {
     if( CRYS_HASH_Init( &ctx->crys_hash_ctx, CRYS_HASH_SHA1_mode ) != CRYS_OK )
-            return ( MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED );
+            return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
     return ( 0 );
 }
 
@@ -57,7 +57,7 @@ int mbedtls_sha1_update_ret( mbedtls_sha1_context *ctx,
                              size_t ilen )
 {
     if( CRYS_HASH_Update( &ctx->crys_hash_ctx, (uint8_t*)input, ilen ) != CRYS_OK )
-        return ( MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED );
+        return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
     return ( 0 );
 }
 
@@ -73,14 +73,14 @@ int mbedtls_sha1_finish_ret( mbedtls_sha1_context *ctx,
         return ( 0 );
     }
     else
-        return ( MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED );
+        return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
 }
 
 int mbedtls_internal_sha1_process( mbedtls_sha1_context *ctx,
                                    const unsigned char data[64] )
 {
     if( CRYS_HASH_Update( &ctx->crys_hash_ctx, (uint8_t*)data, 64 ) != CRYS_OK )
-        return ( MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED );
+        return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
     return ( 0 );
 }
 #endif //MBEDTLS_SHA1_ALT
diff --git a/features/cryptocell/FEATURE_CRYPTOCELL310/sha256_alt.c b/features/cryptocell/FEATURE_CRYPTOCELL310/sha256_alt.c
@@ -47,15 +47,15 @@ int mbedtls_sha256_starts_ret( mbedtls_sha256_context *ctx, int is224 )
 {
     if(CRYS_HASH_Init( &ctx->crys_hash_ctx, is224 ?
                     CRYS_HASH_SHA224_mode : CRYS_HASH_SHA256_mode ) != CRYS_OK )
-        return ( MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED );
+        return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
     return ( 0 );
 }
 
 int mbedtls_internal_sha256_process( mbedtls_sha256_context *ctx,
                                      const unsigned char data[64] )
 {
     if( CRYS_HASH_Update( &ctx->crys_hash_ctx, (uint8_t*)data, 64 ) != CRYS_OK )
-        return ( MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED );
+        return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
     return ( 0 );
 }
 
@@ -64,7 +64,7 @@ int mbedtls_sha256_update_ret( mbedtls_sha256_context *ctx,
                                size_t ilen )
 {
     if( CRYS_HASH_Update( &ctx->crys_hash_ctx, (uint8_t*)input, ilen ) != CRYS_OK )
-        return ( MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED );
+        return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
     return ( 0 );
 }
 
@@ -80,7 +80,7 @@ int mbedtls_sha256_finish_ret( mbedtls_sha256_context *ctx,
         return ( 0 );
     }
     else
-        return ( MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED );
+        return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );
 }
 #endif //MBEDTLS_SHA256_ALT
 
diff --git a/features/mbedtls/targets/TARGET_NUVOTON/TARGET_M480/ecp/ecp_internal_alt.c b/features/mbedtls/targets/TARGET_NUVOTON/TARGET_M480/ecp/ecp_internal_alt.c
@@ -484,7 +484,7 @@ NU_STATIC int internal_run_eccop(const mbedtls_ecp_group *grp,
     
     /* Check supported maximum key bits */
     if (grp->pbits > NU_ECC_MAXKEYBITS) {
-        return MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;
+        return MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED;
     }
 
     int ret;
@@ -675,7 +675,7 @@ NU_STATIC int internal_run_modop(mbedtls_mpi *r,
     
     /* Check supported maximum key bits */
     if (pbits > NU_ECC_MAXKEYBITS) {
-        return MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;
+        return MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED;
     }
     
     /* Check MODOP operations are legal */
diff --git a/features/mbedtls/targets/TARGET_STM/aes_alt.c b/features/mbedtls/targets/TARGET_STM/aes_alt.c
@@ -24,6 +24,7 @@
 #if defined(MBEDTLS_AES_ALT)
 
 #if defined(TARGET_STM32L486xG) || defined (TARGET_STM32L443xC)
+#include "mbedtls/platform.h"
 //the following defines are provided to maintain compatibility between STM32 families
 #define __HAL_RCC_CRYP_CLK_ENABLE    __HAL_RCC_AES_CLK_ENABLE
 #define __HAL_RCC_CRYP_FORCE_RESET   __HAL_RCC_AES_FORCE_RESET
@@ -40,7 +41,7 @@ static int aes_set_key(mbedtls_aes_context *ctx, const unsigned char *key, unsig
             break;
         case 192:
 #if defined (TARGET_STM32L486xG) || defined (TARGET_STM32L443xC)
-            return (MBEDTLS_ERR_AES_INVALID_KEY_LENGTH);
+            return (MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED);
 #else
             ctx->hcryp_aes.Init.KeySize = CRYP_KEYSIZE_192B;
             memcpy(ctx->aes_key, key, 24);
diff --git a/features/mbedtls/targets/TARGET_STM/md5_alt.c b/features/mbedtls/targets/TARGET_STM/md5_alt.c
@@ -99,19 +99,19 @@ int mbedtls_md5_starts_ret(mbedtls_md5_context *ctx)
 {
     /* HASH IP initialization */
     if (HAL_HASH_DeInit(&ctx->hhash_md5) != 0) {
-        return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;
+        return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
     }
 
     /* HASH Configuration */
     ctx->hhash_md5.Init.DataType = HASH_DATATYPE_8B;
     /* clear CR ALGO value */
     HASH->CR &= ~HASH_CR_ALGO_Msk;
     if (HAL_HASH_Init(&ctx->hhash_md5) != 0) {
-        return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;
+        return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
     }
     if (st_md5_save_hw_context(ctx) != 1) {
         // Return HASH_BUSY timeout error here
-        return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;
+        return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
     }
 
     return 0;
@@ -121,14 +121,14 @@ int mbedtls_internal_md5_process(mbedtls_md5_context *ctx, const unsigned char d
 {
     if (st_md5_restore_hw_context(ctx) != 1) {
         // Return HASH_BUSY timeout error here
-        return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;
+        return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
     }
     if (HAL_HASH_MD5_Accumulate(&ctx->hhash_md5, (uint8_t *)data, ST_MD5_BLOCK_SIZE) != 0) {
-        return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;
+        return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
     }
     if (st_md5_save_hw_context(ctx) != 1) {
         // Return HASH_BUSY timeout error here
-        return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;
+        return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
     }
     return 0;
 }
@@ -141,7 +141,7 @@ int mbedtls_md5_update_ret(mbedtls_md5_context *ctx, const unsigned char *input,
     if (currentlen != 0) {
         if (st_md5_restore_hw_context(ctx) != 1) {
             // Return HASH_BUSY timeout error here
-            return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;
+            return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
         }
 
         // store mechanism to accumulate ST_MD5_BLOCK_SIZE bytes (512 bits) in the HW
@@ -161,7 +161,7 @@ int mbedtls_md5_update_ret(mbedtls_md5_context *ctx, const unsigned char *input,
             size_t iter = currentlen / ST_MD5_BLOCK_SIZE;
             if (iter != 0) {
                 if (HAL_HASH_MD5_Accumulate(&ctx->hhash_md5, (uint8_t *)(input + ST_MD5_BLOCK_SIZE - ctx->sbuf_len), (iter * ST_MD5_BLOCK_SIZE)) != 0) {
-                    return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;
+                    return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
                 }
             }
             // sbuf is completely accumulated, now copy up to 63 remaining bytes
@@ -173,7 +173,7 @@ int mbedtls_md5_update_ret(mbedtls_md5_context *ctx, const unsigned char *input,
 
         if (st_md5_save_hw_context(ctx) != 1) {
             // Return HASH_BUSY timeout error here
-            return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;
+            return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
         }
     }
     return 0;
@@ -183,24 +183,24 @@ int mbedtls_md5_finish_ret(mbedtls_md5_context *ctx, unsigned char output[16])
 {
     if (st_md5_restore_hw_context(ctx) != 1) {
         // Return HASH_BUSY timeout error here
-        return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;
+        return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
     }
     /* Last accumulation for extra bytes in sbuf_len */
     /* This sets HW flags in case mbedtls_md5_update has not been called yet */
     if (HAL_HASH_MD5_Accumulate(&ctx->hhash_md5, ctx->sbuf, ctx->sbuf_len) != 0) {
-        return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;
+        return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
     }
 
     mbedtls_zeroize(ctx->sbuf, ST_MD5_BLOCK_SIZE);
     ctx->sbuf_len = 0;
     __HAL_HASH_START_DIGEST();
 
     if (HAL_HASH_MD5_Finish(&ctx->hhash_md5, output, 10)) {
-        return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;
+        return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
     }
     if (st_md5_save_hw_context(ctx) != 1) {
         // Return HASH_BUSY timeout error here
-        return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;
+        return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
     }
     return 0;
 }
diff --git a/features/mbedtls/targets/TARGET_STM/sha1_alt.c b/features/mbedtls/targets/TARGET_STM/sha1_alt.c
diff --git a/features/mbedtls/targets/TARGET_STM/sha256_alt.c b/features/mbedtls/targets/TARGET_STM/sha256_alt.c
diff --git a/features/mbedtls/targets/TARGET_Silicon_Labs/aes_aes.c b/features/mbedtls/targets/TARGET_Silicon_Labs/aes_aes.c
diff --git a/features/mbedtls/targets/TARGET_Silicon_Labs/crypto_ecp.c b/features/mbedtls/targets/TARGET_Silicon_Labs/crypto_ecp.c

Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ uint32_t convert_mbedtls_to_cc_rand( void* mbedtls_rand, uint16_t outSizeBytes,`
`122`	`122`	`*`
`123`	`123`	`*`
`124`	`124`	`* \return \c The corresponding Mbed TLS error,`
`125`		`- * MBEDTLS_ERR_ECP_HW_ACCEL_FAILED as default, if none found`
	`125`	`+ * MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED as default, if none found`
`126`	`126`	`*/`
`127`	`127`	`int convert_CrysError_to_mbedtls_err( CRYSError_t Crys_err );`
`128`	`128`
Original file line number	Diff line number	Diff line change
`@@ -118,7 +118,7 @@ int mbedtls_ecdh_gen_public( mbedtls_ecp_group grp, mbedtls_mpi d, mbedtls_ecp`
`118`	`118`	`MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &Q->Z, 1 ) );`
`119`	`119`	`}`
`120`	`120`	`else`
`121`		`- ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;`
	`121`	`+ ret = MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED;`
`122`	`122`
`123`	`123`	`cleanup:`
`124`	`124`
`@@ -231,7 +231,7 @@ int mbedtls_ecdh_compute_shared( mbedtls_ecp_group grp, mbedtls_mpi z,`
`231`	`231`	`}`
`232`	`232`	`else`
`233`	`233`	`{`
`234`		`- ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;`
	`234`	`+ ret = MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED;`
`235`	`235`	`goto cleanup;`
`236`	`236`	`}`
`237`	`237`
Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ int mbedtls_ecdsa_sign( mbedtls_ecp_group grp, mbedtls_mpi r, mbedtls_mpi *s,`
`132`	`132`	`}`
`133`	`133`	`else`
`134`	`134`	`{`
`135`		`- ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;`
	`135`	`+ ret = MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED;`
`136`	`136`	`goto cleanup;`
`137`	`137`	`}`
`138`	`138`
`@@ -226,7 +226,7 @@ int mbedtls_ecdsa_verify( mbedtls_ecp_group *grp,`
`226`	`226`	`}`
`227`	`227`	`}`
`228`	`228`	`else`
`229`		`- ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;`
	`229`	`+ ret = MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED;`
`230`	`230`
`231`	`231`	`cleanup:`
`232`	`232`
`@@ -313,7 +313,7 @@ int mbedtls_ecdsa_genkey( mbedtls_ecdsa_context *ctx, mbedtls_ecp_group_id gid,`
`313`	`313`	`}`
`314`	`314`	`}`
`315`	`315`	`else`
`316`		`- ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;`
	`316`	`+ ret = MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED;`
`317`	`317`
`318`	`318`
`319`	`319`	`cleanup:`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ void mbedtls_sha1_clone( mbedtls_sha1_context *dst,`
`47`	`47`	`int mbedtls_sha1_starts_ret( mbedtls_sha1_context *ctx )`
`48`	`48`	`{`
`49`	`49`	`if( CRYS_HASH_Init( &ctx->crys_hash_ctx, CRYS_HASH_SHA1_mode ) != CRYS_OK )`
`50`		`- return ( MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED );`
	`50`	`+ return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );`
`51`	`51`	`return ( 0 );`
`52`	`52`	`}`
`53`	`53`
`@@ -57,7 +57,7 @@ int mbedtls_sha1_update_ret( mbedtls_sha1_context *ctx,`
`57`	`57`	`size_t ilen )`
`58`	`58`	`{`
`59`	`59`	`if( CRYS_HASH_Update( &ctx->crys_hash_ctx, (uint8_t*)input, ilen ) != CRYS_OK )`
`60`		`- return ( MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED );`
	`60`	`+ return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );`
`61`	`61`	`return ( 0 );`
`62`	`62`	`}`
`63`	`63`
`@@ -73,14 +73,14 @@ int mbedtls_sha1_finish_ret( mbedtls_sha1_context *ctx,`
`73`	`73`	`return ( 0 );`
`74`	`74`	`}`
`75`	`75`	`else`
`76`		`- return ( MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED );`
	`76`	`+ return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`int mbedtls_internal_sha1_process( mbedtls_sha1_context *ctx,`
`80`	`80`	`const unsigned char data[64] )`
`81`	`81`	`{`
`82`	`82`	`if( CRYS_HASH_Update( &ctx->crys_hash_ctx, (uint8_t*)data, 64 ) != CRYS_OK )`
`83`		`- return ( MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED );`
	`83`	`+ return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );`
`84`	`84`	`return ( 0 );`
`85`	`85`	`}`
`86`	`86`	`#endif //MBEDTLS_SHA1_ALT`
Original file line number	Diff line number	Diff line change
`@@ -47,15 +47,15 @@ int mbedtls_sha256_starts_ret( mbedtls_sha256_context *ctx, int is224 )`
`47`	`47`	`{`
`48`	`48`	`if(CRYS_HASH_Init( &ctx->crys_hash_ctx, is224 ?`
`49`	`49`	`CRYS_HASH_SHA224_mode : CRYS_HASH_SHA256_mode ) != CRYS_OK )`
`50`		`- return ( MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED );`
	`50`	`+ return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );`
`51`	`51`	`return ( 0 );`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`int mbedtls_internal_sha256_process( mbedtls_sha256_context *ctx,`
`55`	`55`	`const unsigned char data[64] )`
`56`	`56`	`{`
`57`	`57`	`if( CRYS_HASH_Update( &ctx->crys_hash_ctx, (uint8_t*)data, 64 ) != CRYS_OK )`
`58`		`- return ( MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED );`
	`58`	`+ return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );`
`59`	`59`	`return ( 0 );`
`60`	`60`	`}`
`61`	`61`
`@@ -64,7 +64,7 @@ int mbedtls_sha256_update_ret( mbedtls_sha256_context *ctx,`
`64`	`64`	`size_t ilen )`
`65`	`65`	`{`
`66`	`66`	`if( CRYS_HASH_Update( &ctx->crys_hash_ctx, (uint8_t*)input, ilen ) != CRYS_OK )`
`67`		`- return ( MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED );`
	`67`	`+ return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );`
`68`	`68`	`return ( 0 );`
`69`	`69`	`}`
`70`	`70`
`@@ -80,7 +80,7 @@ int mbedtls_sha256_finish_ret( mbedtls_sha256_context *ctx,`
`80`	`80`	`return ( 0 );`
`81`	`81`	`}`
`82`	`82`	`else`
`83`		`- return ( MBEDTLS_ERR_SHA256_HW_ACCEL_FAILED );`
	`83`	`+ return ( MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED );`
`84`	`84`	`}`
`85`	`85`	`#endif //MBEDTLS_SHA256_ALT`
`86`	`86`
Original file line number	Diff line number	Diff line change
`@@ -484,7 +484,7 @@ NU_STATIC int internal_run_eccop(const mbedtls_ecp_group *grp,`
`484`	`484`
`485`	`485`	`/* Check supported maximum key bits */`
`486`	`486`	`if (grp->pbits > NU_ECC_MAXKEYBITS) {`
`487`		`- return MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;`
	`487`	`+ return MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED;`
`488`	`488`	`}`
`489`	`489`
`490`	`490`	`int ret;`
`@@ -675,7 +675,7 @@ NU_STATIC int internal_run_modop(mbedtls_mpi *r,`
`675`	`675`
`676`	`676`	`/* Check supported maximum key bits */`
`677`	`677`	`if (pbits > NU_ECC_MAXKEYBITS) {`
`678`		`- return MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;`
	`678`	`+ return MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED;`
`679`	`679`	`}`
`680`	`680`
`681`	`681`	`/* Check MODOP operations are legal */`
Original file line number	Diff line number	Diff line change
`@@ -99,19 +99,19 @@ int mbedtls_md5_starts_ret(mbedtls_md5_context *ctx)`
`99`	`99`	`{`
`100`	`100`	`/* HASH IP initialization */`
`101`	`101`	`if (HAL_HASH_DeInit(&ctx->hhash_md5) != 0) {`
`102`		`- return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;`
	`102`	`+ return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`/* HASH Configuration */`
`106`	`106`	`ctx->hhash_md5.Init.DataType = HASH_DATATYPE_8B;`
`107`	`107`	`/* clear CR ALGO value */`
`108`	`108`	`HASH->CR &= ~HASH_CR_ALGO_Msk;`
`109`	`109`	`if (HAL_HASH_Init(&ctx->hhash_md5) != 0) {`
`110`		`- return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;`
	`110`	`+ return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;`
`111`	`111`	`}`
`112`	`112`	`if (st_md5_save_hw_context(ctx) != 1) {`
`113`	`113`	`// Return HASH_BUSY timeout error here`
`114`		`- return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;`
	`114`	`+ return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`return 0;`
`@@ -121,14 +121,14 @@ int mbedtls_internal_md5_process(mbedtls_md5_context *ctx, const unsigned char d`
`121`	`121`	`{`
`122`	`122`	`if (st_md5_restore_hw_context(ctx) != 1) {`
`123`	`123`	`// Return HASH_BUSY timeout error here`
`124`		`- return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;`
	`124`	`+ return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;`
`125`	`125`	`}`
`126`	`126`	`if (HAL_HASH_MD5_Accumulate(&ctx->hhash_md5, (uint8_t *)data, ST_MD5_BLOCK_SIZE) != 0) {`
`127`		`- return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;`
	`127`	`+ return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;`
`128`	`128`	`}`
`129`	`129`	`if (st_md5_save_hw_context(ctx) != 1) {`
`130`	`130`	`// Return HASH_BUSY timeout error here`
`131`		`- return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;`
	`131`	`+ return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;`
`132`	`132`	`}`
`133`	`133`	`return 0;`
`134`	`134`	`}`
`@@ -141,7 +141,7 @@ int mbedtls_md5_update_ret(mbedtls_md5_context ctx, const unsigned char input,`
`141`	`141`	`if (currentlen != 0) {`
`142`	`142`	`if (st_md5_restore_hw_context(ctx) != 1) {`
`143`	`143`	`// Return HASH_BUSY timeout error here`
`144`		`- return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;`
	`144`	`+ return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`// store mechanism to accumulate ST_MD5_BLOCK_SIZE bytes (512 bits) in the HW`
`@@ -161,7 +161,7 @@ int mbedtls_md5_update_ret(mbedtls_md5_context ctx, const unsigned char input,`
`161`	`161`	`size_t iter = currentlen / ST_MD5_BLOCK_SIZE;`
`162`	`162`	`if (iter != 0) {`
`163`	`163`	`if (HAL_HASH_MD5_Accumulate(&ctx->hhash_md5, (uint8_t )(input + ST_MD5_BLOCK_SIZE - ctx->sbuf_len), (iter ST_MD5_BLOCK_SIZE)) != 0) {`
`164`		`- return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;`
	`164`	`+ return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;`
`165`	`165`	`}`
`166`	`166`	`}`
`167`	`167`	`// sbuf is completely accumulated, now copy up to 63 remaining bytes`
`@@ -173,7 +173,7 @@ int mbedtls_md5_update_ret(mbedtls_md5_context ctx, const unsigned char input,`
`173`	`173`
`174`	`174`	`if (st_md5_save_hw_context(ctx) != 1) {`
`175`	`175`	`// Return HASH_BUSY timeout error here`
`176`		`- return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;`
	`176`	`+ return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;`
`177`	`177`	`}`
`178`	`178`	`}`
`179`	`179`	`return 0;`
`@@ -183,24 +183,24 @@ int mbedtls_md5_finish_ret(mbedtls_md5_context *ctx, unsigned char output[16])`
`183`	`183`	`{`
`184`	`184`	`if (st_md5_restore_hw_context(ctx) != 1) {`
`185`	`185`	`// Return HASH_BUSY timeout error here`
`186`		`- return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;`
	`186`	`+ return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;`
`187`	`187`	`}`
`188`	`188`	`/* Last accumulation for extra bytes in sbuf_len */`
`189`	`189`	`/* This sets HW flags in case mbedtls_md5_update has not been called yet */`
`190`	`190`	`if (HAL_HASH_MD5_Accumulate(&ctx->hhash_md5, ctx->sbuf, ctx->sbuf_len) != 0) {`
`191`		`- return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;`
	`191`	`+ return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;`
`192`	`192`	`}`
`193`	`193`
`194`	`194`	`mbedtls_zeroize(ctx->sbuf, ST_MD5_BLOCK_SIZE);`
`195`	`195`	`ctx->sbuf_len = 0;`
`196`	`196`	`__HAL_HASH_START_DIGEST();`
`197`	`197`
`198`	`198`	`if (HAL_HASH_MD5_Finish(&ctx->hhash_md5, output, 10)) {`
`199`		`- return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;`
	`199`	`+ return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;`
`200`	`200`	`}`
`201`	`201`	`if (st_md5_save_hw_context(ctx) != 1) {`
`202`	`202`	`// Return HASH_BUSY timeout error here`
`203`		`- return MBEDTLS_ERR_MD5_HW_ACCEL_FAILED;`
	`203`	`+ return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;`
`204`	`204`	`}`
`205`	`205`	`return 0;`
`206`	`206`	`}`