diff --git a/wolfcrypt/src/aes.c b/wolfcrypt/src/aes.c
index 184838a6b..02ee5015f 100644
--- a/wolfcrypt/src/aes.c
+++ b/wolfcrypt/src/aes.c
@@ -4011,7 +4011,7 @@ int wc_AesSetIV(Aes* aes, const byte* iv)
     #endif
 
     #ifdef WOLF_CRYPTO_CB
-        if (aes->devId != INVALID_DEVID) {
+        {
             int crypto_cb_ret = wc_CryptoCb_AesCbcEncrypt(aes, out, in, sz);
             if (crypto_cb_ret != CRYPTOCB_UNAVAILABLE)
                 return crypto_cb_ret;
@@ -4144,7 +4144,7 @@ int wc_AesSetIV(Aes* aes, const byte* iv)
     #endif
 
     #ifdef WOLF_CRYPTO_CB
-        if (aes->devId != INVALID_DEVID) {
+        {
             int crypto_cb_ret = wc_CryptoCb_AesCbcDecrypt(aes, out, in, sz);
             if (crypto_cb_ret != CRYPTOCB_UNAVAILABLE)
                 return crypto_cb_ret;
@@ -4462,7 +4462,7 @@ int wc_AesSetIV(Aes* aes, const byte* iv)
             }
 
         #ifdef WOLF_CRYPTO_CB
-            if (aes->devId != INVALID_DEVID) {
+            {
                 int crypto_cb_ret = wc_CryptoCb_AesCtrEncrypt(aes, out, in, sz);
                 if (crypto_cb_ret != CRYPTOCB_UNAVAILABLE)
                     return crypto_cb_ret;
@@ -6655,7 +6655,7 @@ int wc_AesGcmEncrypt(Aes* aes, byte* out, const byte* in, word32 sz,
     }
 
 #ifdef WOLF_CRYPTO_CB
-    if (aes->devId != INVALID_DEVID) {
+    {
         int crypto_cb_ret =
             wc_CryptoCb_AesGcmEncrypt(aes, out, in, sz, iv, ivSz, authTag,
                                       authTagSz, authIn, authInSz);
@@ -7211,7 +7211,7 @@ int wc_AesGcmDecrypt(Aes* aes, byte* out, const byte* in, word32 sz,
     }
 
 #ifdef WOLF_CRYPTO_CB
-    if (aes->devId != INVALID_DEVID) {
+    {
         int crypto_cb_ret =
             wc_CryptoCb_AesGcmDecrypt(aes, out, in, sz, iv, ivSz,
                                       authTag, authTagSz, authIn, authInSz);
@@ -9103,7 +9103,7 @@ int wc_AesCcmEncrypt(Aes* aes, byte* out, const byte* in, word32 inSz,
     }
 
 #ifdef WOLF_CRYPTO_CB
-    if (aes->devId != INVALID_DEVID) {
+    {
         int crypto_cb_ret =
             wc_CryptoCb_AesCcmEncrypt(aes, out, in, inSz, nonce, nonceSz,
                                       authTag, authTagSz, authIn, authInSz);
@@ -9282,7 +9282,7 @@ int  wc_AesCcmDecrypt(Aes* aes, byte* out, const byte* in, word32 inSz,
     }
 
 #ifdef WOLF_CRYPTO_CB
-    if (aes->devId != INVALID_DEVID) {
+    {
         int crypto_cb_ret =
             wc_CryptoCb_AesCcmDecrypt(aes, out, in, inSz, nonce, nonceSz,
             authTag, authTagSz, authIn, authInSz);
@@ -9801,7 +9801,7 @@ static WARN_UNUSED_RESULT int _AesEcbEncrypt(
     word32 blocks = sz / AES_BLOCK_SIZE;
 
 #ifdef WOLF_CRYPTO_CB
-    if (aes->devId != INVALID_DEVID) {
+    {
         int ret = wc_CryptoCb_AesEcbEncrypt(aes, out, in, sz);
         if (ret != CRYPTOCB_UNAVAILABLE)
             return ret;
@@ -9837,7 +9837,7 @@ static WARN_UNUSED_RESULT int _AesEcbDecrypt(
     word32 blocks = sz / AES_BLOCK_SIZE;
 
 #ifdef WOLF_CRYPTO_CB
-    if (aes->devId != INVALID_DEVID) {
+    {
         int ret = wc_CryptoCb_AesEcbDecrypt(aes, out, in, sz);
         if (ret != CRYPTOCB_UNAVAILABLE)
             return ret;
diff --git a/wolfcrypt/src/cmac.c b/wolfcrypt/src/cmac.c
index 2ceefd7ac..65f61dc20 100644
--- a/wolfcrypt/src/cmac.c
+++ b/wolfcrypt/src/cmac.c
@@ -115,7 +115,7 @@ int wc_InitCmac_ex(Cmac* cmac, const byte* key, word32 keySz,
     XMEMSET(cmac, 0, sizeof(Cmac));
 
 #ifdef WOLF_CRYPTO_CB
-    if (devId != INVALID_DEVID) {
+    {
         cmac->devId = devId;
         cmac->devCtx = NULL;
 
@@ -178,7 +178,7 @@ int wc_CmacUpdate(Cmac* cmac, const byte* in, word32 inSz)
     }
 
 #ifdef WOLF_CRYPTO_CB
-    if (cmac->devId != INVALID_DEVID) {
+    {
         ret = wc_CryptoCb_Cmac(cmac, NULL, 0, in, inSz,
                 NULL, NULL, 0, NULL);
         if (ret != CRYPTOCB_UNAVAILABLE)
@@ -226,12 +226,10 @@ int wc_CmacFinal(Cmac* cmac, byte* out, word32* outSz)
     }
 
 #ifdef WOLF_CRYPTO_CB
-    if (cmac->devId != INVALID_DEVID) {
-        ret = wc_CryptoCb_Cmac(cmac, NULL, 0, NULL, 0, out, outSz, 0, NULL);
-        if (ret != CRYPTOCB_UNAVAILABLE)
-            return ret;
-        /* fall-through when unavailable */
-    }
+    ret = wc_CryptoCb_Cmac(cmac, NULL, 0, NULL, 0, out, outSz, 0, NULL);
+    if (ret != CRYPTOCB_UNAVAILABLE)
+        return ret;
+    /* fall-through when unavailable */
 #endif
 
     if (cmac->bufferSz == AES_BLOCK_SIZE) {
diff --git a/wolfcrypt/src/ecc.c b/wolfcrypt/src/ecc.c
index 2a183d739..bc4a8926c 100644
--- a/wolfcrypt/src/ecc.c
+++ b/wolfcrypt/src/ecc.c
@@ -4428,16 +4428,14 @@ int wc_ecc_shared_secret(ecc_key* private_key, ecc_key* public_key, byte* out,
    }
 
 #ifdef WOLF_CRYPTO_CB
-    if (private_key->devId != INVALID_DEVID) {
-        err = wc_CryptoCb_Ecdh(private_key, public_key, out, outlen);
+    err = wc_CryptoCb_Ecdh(private_key, public_key, out, outlen);
     #ifndef WOLF_CRYPTO_CB_ONLY_ECC
-        if (err != CRYPTOCB_UNAVAILABLE)
-            return err;
-        /* fall-through when unavailable */
+    if (err != CRYPTOCB_UNAVAILABLE)
+        return err;
+    /* fall-through when unavailable */
     #endif
-    }
     #ifdef WOLF_CRYPTO_CB_ONLY_ECC
-    else {
+    if (err == CRYPTOCB_UNAVAILABLE) {
         err = NO_VALID_DEVID;
     }
     #endif
@@ -5326,18 +5324,14 @@ static int _ecc_make_key_ex(WC_RNG* rng, int keysize, ecc_key* key,
     key->flags = (byte)flags;
 
 #ifdef WOLF_CRYPTO_CB
-    if (key->devId != INVALID_DEVID) {
-        err = wc_CryptoCb_MakeEccKey(rng, keysize, key, curve_id);
+    err = wc_CryptoCb_MakeEccKey(rng, keysize, key, curve_id);
     #ifndef WOLF_CRYPTO_CB_ONLY_ECC
-        if (err != CRYPTOCB_UNAVAILABLE)
-            return err;
-        /* fall-through when unavailable */
-    #else
+    if (err != CRYPTOCB_UNAVAILABLE)
         return err;
+    /* fall-through when unavailable */
     #endif
-    }
     #ifdef WOLF_CRYPTO_CB_ONLY_ECC
-    else {
+    if (err == CRYPTOCB_UNAVAILABLE) {
         return NO_VALID_DEVID;
     }
     #endif
@@ -6316,16 +6310,14 @@ int wc_ecc_sign_hash(const byte* in, word32 inlen, byte* out, word32 *outlen,
     }
 
 #ifdef WOLF_CRYPTO_CB
-    if (key->devId != INVALID_DEVID) {
-        err = wc_CryptoCb_EccSign(in, inlen, out, outlen, rng, key);
+    err = wc_CryptoCb_EccSign(in, inlen, out, outlen, rng, key);
     #ifndef WOLF_CRYPTO_CB_ONLY_ECC
-        if (err != CRYPTOCB_UNAVAILABLE)
-            return err;
-        /* fall-through when unavailable */
+    if (err != CRYPTOCB_UNAVAILABLE)
+        return err;
+    /* fall-through when unavailable */
     #endif
-    }
     #ifdef WOLF_CRYPTO_CB_ONLY_ECC
-    else {
+    if (err == CRYPTOCB_UNAVAILABLE) {
         err = NO_VALID_DEVID;
     }
     #endif
@@ -8016,16 +8008,14 @@ int wc_ecc_verify_hash(const byte* sig, word32 siglen, const byte* hash,
     }
 
 #ifdef WOLF_CRYPTO_CB
-    if (key->devId != INVALID_DEVID) {
-        err = wc_CryptoCb_EccVerify(sig, siglen, hash, hashlen, res, key);
+    err = wc_CryptoCb_EccVerify(sig, siglen, hash, hashlen, res, key);
     #ifndef WOLF_CRYPTO_CB_ONLY_ECC
-        if (err != CRYPTOCB_UNAVAILABLE)
-            return err;
-        /* fall-through when unavailable */
+    if (err != CRYPTOCB_UNAVAILABLE)
+        return err;
+    /* fall-through when unavailable */
     #endif
-    }
     #ifdef WOLF_CRYPTO_CB_ONLY_ECC
-    else {
+    if (err == CRYPTOCB_UNAVAILABLE) {
         err = NO_VALID_DEVID;
     }
     #endif
diff --git a/wolfcrypt/src/random.c b/wolfcrypt/src/random.c
index 885d973d5..f2dcd5bd4 100644
--- a/wolfcrypt/src/random.c
+++ b/wolfcrypt/src/random.c
@@ -1829,12 +1829,10 @@ int wc_RNG_GenerateBlock(WC_RNG* rng, byte* output, word32 sz)
         return 0;
 
 #ifdef WOLF_CRYPTO_CB
-    if (rng->devId != INVALID_DEVID) {
-        ret = wc_CryptoCb_RandomBlock(rng, output, sz);
-        if (ret != CRYPTOCB_UNAVAILABLE)
-            return ret;
-        /* fall-through when unavailable */
-    }
+    ret = wc_CryptoCb_RandomBlock(rng, output, sz);
+    if (ret != CRYPTOCB_UNAVAILABLE)
+        return ret;
+    /* fall-through when unavailable */
 #endif
 
 #ifdef HAVE_INTEL_RDRAND
@@ -2583,7 +2581,7 @@ int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
 #ifdef WOLF_CRYPTO_CB
     int ret;
 
-    if (os != NULL && os->devId != INVALID_DEVID) {
+    if (os != NULL) {
         ret = wc_CryptoCb_RandomSeed(os, output, sz);
         if (ret != CRYPTOCB_UNAVAILABLE)
             return ret;
@@ -3702,7 +3700,7 @@ int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
         }
 
     #ifdef WOLF_CRYPTO_CB
-        if (os->devId != INVALID_DEVID) {
+        {
             ret = wc_CryptoCb_RandomSeed(os, output, sz);
             if (ret != CRYPTOCB_UNAVAILABLE)
                 return ret;
diff --git a/wolfcrypt/src/rsa.c b/wolfcrypt/src/rsa.c
index fac7e3c14..87d75099e 100644
--- a/wolfcrypt/src/rsa.c
+++ b/wolfcrypt/src/rsa.c
@@ -3172,18 +3172,14 @@ static int wc_RsaFunction_ex(const byte* in, word32 inLen, byte* out,
     }
 
 #ifdef WOLF_CRYPTO_CB
-    if (key->devId != INVALID_DEVID) {
-        ret = wc_CryptoCb_Rsa(in, inLen, out, outLen, type, key, rng);
+    ret = wc_CryptoCb_Rsa(in, inLen, out, outLen, type, key, rng);
     #ifndef WOLF_CRYPTO_CB_ONLY_RSA
-        if (ret != CRYPTOCB_UNAVAILABLE)
-            return ret;
-        /* fall-through when unavailable and try using software */
-    #else
+    if (ret != CRYPTOCB_UNAVAILABLE)
         return ret;
+    /* fall-through when unavailable and try using software */
     #endif
-    }
     #ifdef WOLF_CRYPTO_CB_ONLY_RSA
-    else {
+    if (ret == CRYPTOCB_UNAVAILABLE)
         return NO_VALID_DEVID;
     }
     #endif
@@ -4768,18 +4764,14 @@ int wc_MakeRsaKey(RsaKey* key, int size, long e, WC_RNG* rng)
 #endif
 
 #ifdef WOLF_CRYPTO_CB
-    if (key->devId != INVALID_DEVID) {
-        err = wc_CryptoCb_MakeRsaKey(key, size, e, rng);
+    err = wc_CryptoCb_MakeRsaKey(key, size, e, rng);
     #ifndef WOLF_CRYPTO_CB_ONLY_RSA
-        if (err != CRYPTOCB_UNAVAILABLE)
-            goto out;
-        /* fall-through when unavailable */
-    #else
+    if (err != CRYPTOCB_UNAVAILABLE)
         goto out;
+    /* fall-through when unavailable */
     #endif
-    }
     #ifdef WOLF_CRYPTO_CB_ONLY_RSA
-    else {
+    if (err == CRYPTOCB_UNAVAILABLE)
         err = NO_VALID_DEVID;
         goto out;
     }
diff --git a/wolfcrypt/src/sha256.c b/wolfcrypt/src/sha256.c
index 94bdc2653..2220b7053 100644
--- a/wolfcrypt/src/sha256.c
+++ b/wolfcrypt/src/sha256.c
@@ -1231,7 +1231,7 @@ static int InitSha256(wc_Sha256* sha256)
         }
 
     #ifdef WOLF_CRYPTO_CB
-        if (sha256->devId != INVALID_DEVID) {
+        {
             int ret = wc_CryptoCb_Sha256Hash(sha256, data, len, NULL);
             if (ret != CRYPTOCB_UNAVAILABLE)
                 return ret;
@@ -1394,12 +1394,10 @@ static int InitSha256(wc_Sha256* sha256)
         }
 
     #ifdef WOLF_CRYPTO_CB
-        if (sha256->devId != INVALID_DEVID) {
-            ret = wc_CryptoCb_Sha256Hash(sha256, NULL, 0, hash);
-            if (ret != CRYPTOCB_UNAVAILABLE)
-                return ret;
-            /* fall-through when unavailable */
-        }
+        ret = wc_CryptoCb_Sha256Hash(sha256, NULL, 0, hash);
+        if (ret != CRYPTOCB_UNAVAILABLE)
+            return ret;
+        /* fall-through when unavailable */
     #endif
 
     #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA256)
diff --git a/wolfcrypt/src/sha512.c b/wolfcrypt/src/sha512.c
index f4e77ccc2..0803b2b8a 100644
--- a/wolfcrypt/src/sha512.c
+++ b/wolfcrypt/src/sha512.c
@@ -952,7 +952,7 @@ int wc_Sha512Update(wc_Sha512* sha512, const byte* data, word32 len)
     }
 
 #ifdef WOLF_CRYPTO_CB
-    if (sha512->devId != INVALID_DEVID) {
+    {
         int ret = wc_CryptoCb_Sha512Hash(sha512, data, len, NULL);
         if (ret != CRYPTOCB_UNAVAILABLE)
             return ret;
@@ -1151,7 +1151,7 @@ static int Sha512_Family_Final(wc_Sha512* sha512, byte* hash, size_t digestSz,
     }
 
 #ifdef WOLF_CRYPTO_CB
-    if (sha512->devId != INVALID_DEVID) {
+    {
         byte localHash[WC_SHA512_DIGEST_SIZE];
         ret = wc_CryptoCb_Sha512Hash(sha512, NULL, 0, localHash);
         if (ret != CRYPTOCB_UNAVAILABLE) {
@@ -1374,7 +1374,7 @@ int wc_Sha384Update(wc_Sha384* sha384, const byte* data, word32 len)
     }
 
 #ifdef WOLF_CRYPTO_CB
-    if (sha384->devId != INVALID_DEVID) {
+    {
         int ret = wc_CryptoCb_Sha384Hash(sha384, data, len, NULL);
         if (ret != CRYPTOCB_UNAVAILABLE)
             return ret;
@@ -1423,12 +1423,10 @@ int wc_Sha384Final(wc_Sha384* sha384, byte* hash)
     }
 
 #ifdef WOLF_CRYPTO_CB
-    if (sha384->devId != INVALID_DEVID) {
-        ret = wc_CryptoCb_Sha384Hash(sha384, NULL, 0, hash);
-        if (ret != CRYPTOCB_UNAVAILABLE)
-            return ret;
-        /* fall-through when unavailable */
-    }
+    ret = wc_CryptoCb_Sha384Hash(sha384, NULL, 0, hash);
+    if (ret != CRYPTOCB_UNAVAILABLE)
+        return ret;
+    /* fall-through when unavailable */
 #endif
 #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA384)
     if (sha384->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA384) {