fix code formating and turn on HW acc. by default

IDE/Renesas/e2studio/DK-S7G2/README.md

@@ -31,6 +31,7 @@ The wolfcryptest runs through all of the unit tests from wolfcrypt/test/test.c
 ## Advanced Overriding Driver Name
 Defaults are set for when accessing the driver but the default names may not always work for an existing project. These are the macros and their defaults that could be mapped to other driver names:
 
+```
 /* For main SCE open and close */
 WOLFSSL_SCE_GSCE_HANDLE g_sce
 
@@ -44,7 +45,7 @@ WOLFSSL_SCE_SHA256_HANDLE g_sce_hash_0
 
 /* TRNG access */
 WOLFSSL_SCE_TRNG_HANDLE g_sce_trng
-
+```
 
 
 An example of remapping a driver name would be the following added to a wolfSSL user_settings.h file:

IDE/Renesas/e2studio/DK-S7G2/benchmark-template/src/app_entry.c

@@ -71,7 +71,7 @@ static void benchmark_TLS(int version, char* suites, int group)
         case 3: method = wolfTLSv1_3_client_method(); break;
 #endif
         default:
-            printf("Unknown TLS version (Check if wolfSSL was built with it supported)\n");
+            printf("Unknown TLS version (Check if built with it supported)\n");
             return;
     }
 
@@ -136,13 +136,15 @@ static void benchmark_TLS(int version, char* suites, int group)
     }
     for (i = 0; i < CONNECTION_TIMES; i++) {
 
-        ret = (int)nx_tcp_client_socket_bind(&sockfd, NX_ANY_PORT, NX_WAIT_FOREVER);
+        ret = (int)nx_tcp_client_socket_bind(&sockfd, NX_ANY_PORT,
+                NX_WAIT_FOREVER);
         if (ret != NX_SUCCESS) {
             printf("failed to bind socket\n");
             return;
         }
 
-        ret = (int)nx_tcp_client_socket_connect(&sockfd, TEST_IP, TEST_PORT, NX_WAIT_FOREVER);
+        ret = (int)nx_tcp_client_socket_connect(&sockfd, TEST_IP, TEST_PORT,
+                NX_WAIT_FOREVER);
         if (ret != NX_SUCCESS) {
             printf("failed to connect with error 0x%X\n", ret);
             return;
@@ -208,7 +210,8 @@ static void benchmark_TCP()
         NX_PACKET* response;
         printf("Pinging server to see if up .. ");
         fflush(stdout);
-        ret = (int)nx_icmp_ping(&g_ip0, TEST_IP, "Hello", strlen("Hello"), &response,  2000);
+        ret = (int)nx_icmp_ping(&g_ip0, TEST_IP, "Hello", strlen("Hello"),
+                &response, 2000);
         if (ret != NX_SUCCESS) {
             printf("Unable to ping server, error = 0x%X\n", ret);
             return;
@@ -228,13 +231,15 @@ static void benchmark_TCP()
     }
 
     for (i = 0; i < CONNECTION_TIMES; i++) {
-        ret = (int)nx_tcp_client_socket_bind(&sockfd, NX_ANY_PORT, NX_WAIT_FOREVER);
+        ret = (int)nx_tcp_client_socket_bind(&sockfd, NX_ANY_PORT,
+                NX_WAIT_FOREVER);
         if (ret != NX_SUCCESS) {
             printf("failed to bind socket\n");
             return;
         }
 
-        ret = (int)nx_tcp_client_socket_connect(&sockfd, TEST_IP, TEST_PORT, NX_WAIT_FOREVER);
+        ret = (int)nx_tcp_client_socket_connect(&sockfd, TEST_IP, TEST_PORT,
+                NX_WAIT_FOREVER);
         if (ret != NX_SUCCESS) {
             printf("failed to connect with error 0x%X\n", ret);
             return;

IDE/Renesas/e2studio/DK-S7G2/example_server-template/src/app_entry.c

@@ -103,7 +103,8 @@ static void server()
 #endif
     printf("Waiting for connections on port %d\n", TEST_PORT);
 
-    ret = (int)nx_tcp_socket_create(&g_ip0, &sockfd, "TLS_SERVER", NX_IP_NORMAL, NX_FRAGMENT_OKAY, NX_IP_TIME_TO_LIVE, 1500, NX_NULL, NX_NULL);
+    ret = (int)nx_tcp_socket_create(&g_ip0, &sockfd, "TLS_SERVER", NX_IP_NORMAL,
+            NX_FRAGMENT_OKAY, NX_IP_TIME_TO_LIVE, 1500, NX_NULL, NX_NULL);
     if (ret != NX_SUCCESS) {
         printf("failed to create socket err = 0x%X\n", ret);
     }

IDE/Renesas/e2studio/DK-S7G2/user_settings.h

@@ -16,13 +16,13 @@
 #define WOLFSSL_SCE
 
 /* Used to turn off TRNG */
-#define WOLFSSL_SCE_NO_TRNG
+/* #define WOLFSSL_SCE_NO_TRNG */
 
 /* Used to turn off AES hardware acc. */
-#define WOLFSSL_SCE_NO_AES
+/* #define WOLFSSL_SCE_NO_AES */
 
 /* Used to turn off HASH hardware acc. */
-#define WOLFSSL_SCE_NO_HASH
+/* #define WOLFSSL_SCE_NO_HASH */
 
 #if defined(WOLFSSL_SCE_NO_TRNG)
     /* use unsafe test seed if TRNG not used (not for production) */

wolfcrypt/src/aes.c

@@ -788,34 +788,39 @@
         #define WOLFSSL_SCE_AES128_HANDLE g_sce_aes_128
     #endif
 
-    static int AES_ECB_encrypt(Aes* aes, const byte* inBlock, byte* outBlock, int sz)
+    static int AES_ECB_encrypt(Aes* aes, const byte* inBlock, byte* outBlock,
+            int sz)
     {
         uint32_t ret;
 
-        if (WOLFSSL_SCE_GSCE_HANDLE.p_cfg->endian_flag == CRYPTO_WORD_ENDIAN_BIG) {
+        if (WOLFSSL_SCE_GSCE_HANDLE.p_cfg->endian_flag ==
+                CRYPTO_WORD_ENDIAN_BIG) {
             ByteReverseWords((word32*)inBlock, (word32*)inBlock, sz);
         }
 
         switch (aes->keylen) {
         #ifdef WOLFSSL_AES_128
             case AES_128_KEY_SIZE:
-                ret = WOLFSSL_SCE_AES128_HANDLE.p_api->encrypt(WOLFSSL_SCE_AES128_HANDLE.p_ctrl, aes->key,
-                                                       NULL, (sz / sizeof(word32)),
-                                                       (word32*)inBlock, (word32*)outBlock);
+                ret = WOLFSSL_SCE_AES128_HANDLE.p_api->encrypt(
+                        WOLFSSL_SCE_AES128_HANDLE.p_ctrl, aes->key,
+                        NULL, (sz / sizeof(word32)), (word32*)inBlock,
+                        (word32*)outBlock);
                 break;
         #endif
         #ifdef WOLFSSL_AES_192
             case AES_192_KEY_SIZE:
-                ret = WOLFSSL_SCE_AES192_HANDLE.p_api->encrypt(WOLFSSL_SCE_AES192_HANDLE.p_ctrl, aes->key,
-                                                       NULL, (sz / sizeof(word32)),
-                                                       (word32*)inBlock, (word32*)outBlock);
+                ret = WOLFSSL_SCE_AES192_HANDLE.p_api->encrypt(
+                        WOLFSSL_SCE_AES192_HANDLE.p_ctrl, aes->key,
+                        NULL, (sz / sizeof(word32)), (word32*)inBlock,
+                        (word32*)outBlock);
                 break;
         #endif
         #ifdef WOLFSSL_AES_256
             case AES_256_KEY_SIZE:
-                ret = WOLFSSL_SCE_AES256_HANDLE.p_api->encrypt(WOLFSSL_SCE_AES256_HANDLE.p_ctrl, aes->key,
-                                                       NULL, (sz / sizeof(word32)),
-                                                       (word32*)inBlock, (word32*)outBlock);
+                ret = WOLFSSL_SCE_AES256_HANDLE.p_api->encrypt(
+                        WOLFSSL_SCE_AES256_HANDLE.p_ctrl, aes->key,
+                        NULL, (sz / sizeof(word32)), (word32*)inBlock,
+                        (word32*)outBlock);
                 break;
         #endif
             default:
@@ -824,45 +829,56 @@
         }
 
         if (ret != SSP_SUCCESS) {
-            ByteReverseWords((word32*)inBlock, (word32*)inBlock, sz); /* revert input*/
+           /* revert input */
+            ByteReverseWords((word32*)inBlock, (word32*)inBlock, sz);
             return WC_HW_E;
         }
 
-        if (WOLFSSL_SCE_GSCE_HANDLE.p_cfg->endian_flag == CRYPTO_WORD_ENDIAN_BIG) {
+        if (WOLFSSL_SCE_GSCE_HANDLE.p_cfg->endian_flag ==
+                CRYPTO_WORD_ENDIAN_BIG) {
             ByteReverseWords((word32*)outBlock, (word32*)outBlock, sz);
             if (inBlock != outBlock) {
-                ByteReverseWords((word32*)inBlock, (word32*)inBlock, sz); /* revert input*/
+                /* revert input */
+                ByteReverseWords((word32*)inBlock, (word32*)inBlock, sz);
             }
         }
         return 0;
     }
 
     #if defined(HAVE_AES_DECRYPT)
-    static int AES_ECB_decrypt(Aes* aes, const byte* inBlock, byte* outBlock, int sz)
+    static int AES_ECB_decrypt(Aes* aes, const byte* inBlock, byte* outBlock,
+            int sz)
     {
         uint32_t ret;
 
-        if (WOLFSSL_SCE_GSCE_HANDLE.p_cfg->endian_flag == CRYPTO_WORD_ENDIAN_BIG) {
+        if (WOLFSSL_SCE_GSCE_HANDLE.p_cfg->endian_flag ==
+                CRYPTO_WORD_ENDIAN_BIG) {
             ByteReverseWords((word32*)inBlock, (word32*)inBlock, sz);
         }
 
         switch (aes->keylen) {
         #ifdef WOLFSSL_AES_128
             case AES_128_KEY_SIZE:
-                ret = WOLFSSL_SCE_AES128_HANDLE.p_api->decrypt(WOLFSSL_SCE_AES128_HANDLE.p_ctrl, aes->key, aes->reg,
-                                                                       (sz / sizeof(word32)), (word32*)inBlock, (word32*)outBlock);
+                ret = WOLFSSL_SCE_AES128_HANDLE.p_api->decrypt(
+                        WOLFSSL_SCE_AES128_HANDLE.p_ctrl, aes->key, aes->reg,
+                        (sz / sizeof(word32)), (word32*)inBlock,
+                        (word32*)outBlock);
                 break;
         #endif
         #ifdef WOLFSSL_AES_192
             case AES_192_KEY_SIZE:
-                ret = WOLFSSL_SCE_AES192_HANDLE.p_api->decrypt(WOLFSSL_SCE_AES192_HANDLE.p_ctrl, aes->key, aes->reg,
-                                                                       (sz / sizeof(word32)), (word32*)inBlock, (word32*)outBlock);
+                ret = WOLFSSL_SCE_AES192_HANDLE.p_api->decrypt(
+                        WOLFSSL_SCE_AES192_HANDLE.p_ctrl, aes->key, aes->reg,
+                        (sz / sizeof(word32)), (word32*)inBlock,
+                        (word32*)outBlock);
                 break;
         #endif
         #ifdef WOLFSSL_AES_256
             case AES_256_KEY_SIZE:
-                ret = WOLFSSL_SCE_AES256_HANDLE.p_api->decrypt(WOLFSSL_SCE_AES256_HANDLE.p_ctrl, aes->key, aes->reg,
-                                                                       (sz / sizeof(word32)), (word32*)inBlock, (word32*)outBlock);
+                ret = WOLFSSL_SCE_AES256_HANDLE.p_api->decrypt(
+                        WOLFSSL_SCE_AES256_HANDLE.p_ctrl, aes->key, aes->reg,
+                        (sz / sizeof(word32)), (word32*)inBlock,
+                        (word32*)outBlock);
                 break;
         #endif
             default:
@@ -873,10 +889,12 @@
             return WC_HW_E;
         }
 
-        if (WOLFSSL_SCE_GSCE_HANDLE.p_cfg->endian_flag == CRYPTO_WORD_ENDIAN_BIG) {
+        if (WOLFSSL_SCE_GSCE_HANDLE.p_cfg->endian_flag ==
+                CRYPTO_WORD_ENDIAN_BIG) {
             ByteReverseWords((word32*)outBlock, (word32*)outBlock, sz);
             if (inBlock != outBlock) {
-                ByteReverseWords((word32*)inBlock, (word32*)inBlock, sz); /* revert input*/
+                /* revert input */
+                ByteReverseWords((word32*)inBlock, (word32*)inBlock, sz);
             }
         }
 
@@ -1559,8 +1577,8 @@ static void wc_AesEncrypt(Aes* aes, const byte* inBlock, byte* outBlock)
             tmp_align = tmp + (AESNI_ALIGN - ((size_t)tmp % AESNI_ALIGN));
 
             XMEMCPY(tmp_align, inBlock, AES_BLOCK_SIZE);
-            AES_ECB_encrypt(tmp_align, tmp_align, AES_BLOCK_SIZE, (byte*)aes->key,
-                            aes->rounds);
+            AES_ECB_encrypt(tmp_align, tmp_align, AES_BLOCK_SIZE,
+                    (byte*)aes->key, aes->rounds);
             XMEMCPY(outBlock, tmp_align, AES_BLOCK_SIZE);
             XFREE(tmp, aes->heap, DYNAMIC_TYPE_TMP_BUFFER);
             return;

wolfcrypt/src/sha256.c

@@ -555,23 +555,29 @@ static int InitSha256(wc_Sha256* sha256)
     #define XTRANSFORM(S, D) wc_Sha256SCE_XTRANSFORM((S), (D))
     static int wc_Sha256SCE_XTRANSFORM(wc_Sha256* sha256, const byte* data)
     {
-        if (WOLFSSL_SCE_GSCE_HANDLE.p_cfg->endian_flag == CRYPTO_WORD_ENDIAN_LITTLE)
+        if (WOLFSSL_SCE_GSCE_HANDLE.p_cfg->endian_flag ==
+                CRYPTO_WORD_ENDIAN_LITTLE)
         {
-            ByteReverseWords((word32*)data, (word32*)data, WC_SHA256_BLOCK_SIZE);
-            ByteReverseWords(sha256->digest, sha256->digest, WC_SHA256_DIGEST_SIZE);
+            ByteReverseWords((word32*)data, (word32*)data,
+                    WC_SHA256_BLOCK_SIZE);
+            ByteReverseWords(sha256->digest, sha256->digest,
+                    WC_SHA256_DIGEST_SIZE);
         }
 
-        if (WOLFSSL_SCE_SHA256_HANDLE.p_api->hashUpdate(WOLFSSL_SCE_SHA256_HANDLE.p_ctrl,
-                                                        (word32*)data, WC_SHA256_DIGEST_WORD_SIZE,
-                                                        sha256->digest) != SSP_SUCCESS) {
+        if (WOLFSSL_SCE_SHA256_HANDLE.p_api->hashUpdate(
+                    WOLFSSL_SCE_SHA256_HANDLE.p_ctrl, (word32*)data,
+                    WC_SHA256_DIGEST_WORD_SIZE, sha256->digest) != SSP_SUCCESS){
             WOLFSSL_MSG("Unexpected hardware return value");
             return WC_HW_E;
         }
 
-        if (WOLFSSL_SCE_GSCE_HANDLE.p_cfg->endian_flag == CRYPTO_WORD_ENDIAN_LITTLE)
+        if (WOLFSSL_SCE_GSCE_HANDLE.p_cfg->endian_flag ==
+                CRYPTO_WORD_ENDIAN_LITTLE)
         {
-            ByteReverseWords((word32*)data, (word32*)data, WC_SHA256_BLOCK_SIZE);
-            ByteReverseWords(sha256->digest, sha256->digest, WC_SHA256_DIGEST_SIZE);
+            ByteReverseWords((word32*)data, (word32*)data,
+                    WC_SHA256_BLOCK_SIZE);
+            ByteReverseWords(sha256->digest, sha256->digest,
+                    WC_SHA256_DIGEST_SIZE);
         }
 
         return 0;

wolfcrypt/src/wc_port.c

@@ -229,8 +229,8 @@ int wolfCrypt_Init(void)
 #endif
 
 #ifdef WOLFSSL_SCE
-        ret = (int)WOLFSSL_SCE_GSCE_HANDLE.p_api->open(WOLFSSL_SCE_GSCE_HANDLE.p_ctrl,
-                                                       WOLFSSL_SCE_GSCE_HANDLE.p_cfg);
+        ret = (int)WOLFSSL_SCE_GSCE_HANDLE.p_api->open(
+                WOLFSSL_SCE_GSCE_HANDLE.p_ctrl, WOLFSSL_SCE_GSCE_HANDLE.p_cfg);
         if (ret == SSP_ERR_CRYPTO_SCE_ALREADY_OPEN) {
             WOLFSSL_MSG("SCE already open");
             ret = 0;