luna - wolfssl/wolfcrypt/src/port/maxim/max3266x.c

   1/* max3266x.c
   2 *
   3 * Copyright (C) 2006-2026 wolfSSL Inc.
   4 *
   5 * This file is part of wolfSSL.
   6 *
   7 * wolfSSL is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 3 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * wolfSSL is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  20 */
  21
  22#ifdef HAVE_CONFIG_H
  23    #include <config.h>
  24#endif
  25
  26#include <wolfssl/wolfcrypt/settings.h>
  27
  28#if defined(WOLFSSL_MAX3266X) || defined(WOLFSSL_MAX3266X_OLD)
  29
  30#include <stdint.h>
  31#include <stdarg.h>
  32
  33#include <wolfssl/wolfcrypt/wolfmath.h>
  34#include <wolfssl/wolfcrypt/error-crypt.h>
  35#include <wolfssl/wolfcrypt/logging.h>
  36#include <wolfssl/wolfcrypt/port/maxim/max3266x.h>
  37#include <wolfssl/wolfcrypt/hash.h>
  38#ifdef NO_INLINE
  39    #include <wolfssl/wolfcrypt/misc.h>
  40#else
  41    #define WOLFSSL_MISC_INCLUDED
  42    #include <wolfcrypt/src/misc.c>
  43#endif
  44
  45#ifdef WOLF_CRYPTO_CB
  46    #include <wolfssl/wolfcrypt/port/maxim/max3266x-cryptocb.h>
  47#endif
  48
  49#if defined(USE_FAST_MATH) || defined(USE_INTEGER_HEAP_MATH)
  50    #error  MXC Not Compatible with Fast Math or Heap Math
  51    #include <wolfssl/wolfcrypt/tfm.h>
  52    #define MXC_WORD_SIZE               DIGIT_BIT
  53#elif defined(WOLFSSL_SP_MATH_ALL)
  54    #include <wolfssl/wolfcrypt/sp_int.h>
  55    #define MXC_WORD_SIZE               SP_WORD_SIZE
  56#else
  57    #error MXC HW port needs #define WOLFSSL_SP_MATH_ALL
  58#endif
  59
  60/* Max size MAA can handle */
  61#define MXC_MAA_MAX_SIZE (2048 / MXC_WORD_SIZE)
  62
  63int wc_MXC_TPU_Init(void)
  64{
  65    /* Initialize the TPU device */
  66    if (MXC_TPU_Init(MXC_SYS_PERIPH_CLOCK_TRNG) != 0) {
  67        MAX3266X_MSG("Device did not initialize");
  68        return RNG_FAILURE_E;
  69    }
  70    return 0;
  71}
  72
  73int wc_MXC_TPU_Shutdown(void)
  74{
  75    /* Shutdown the TPU device */
  76#if defined(WOLFSSL_MAX3266X_OLD)
  77    MXC_TPU_Shutdown(); /* Is a void return in older SDK */
  78#else
  79    if (MXC_TPU_Shutdown(MXC_SYS_PERIPH_CLOCK_TRNG) != 0) {
  80        MAX3266X_MSG("Device did not shutdown");
  81        return RNG_FAILURE_E;
  82    }
  83#endif
  84    MAX3266X_MSG("TPU Hardware Shutdown");
  85    return 0;
  86}
  87
  88
  89#ifdef WOLF_CRYPTO_CB
  90int wc_MxcAesCryptoCb(wc_CryptoInfo* info)
  91{
  92    switch (info->cipher.type) {
  93#ifdef HAVE_AES_CBC
  94        case WC_CIPHER_AES_CBC:
  95            if (info->cipher.enc == 1) {
  96                return wc_MxcCb_AesCbcEncrypt(info->cipher.aescbc.aes,
  97                                                info->cipher.aescbc.out,
  98                                                info->cipher.aescbc.in,
  99                                                info->cipher.aescbc.sz);
 100            }
 101            #ifdef HAVE_AES_DECRYPT
 102            else if (info->cipher.enc == 0) {
 103                return wc_MxcCb_AesCbcDecrypt(info->cipher.aescbc.aes,
 104                                                info->cipher.aescbc.out,
 105                                                info->cipher.aescbc.in,
 106                                                info->cipher.aescbc.sz);
 107                }
 108            #endif
 109            break; /* Break out and return error */
 110#endif
 111#ifdef HAVE_AES_ECB
 112        case WC_CIPHER_AES_ECB:
 113            if (info->cipher.enc == 1) {
 114                return wc_MxcCb_AesEcbEncrypt(info->cipher.aesecb.aes,
 115                                                info->cipher.aesecb.out,
 116                                                info->cipher.aesecb.in,
 117                                                info->cipher.aesecb.sz);
 118            }
 119            #ifdef HAVE_AES_DECRYPT
 120            else if (info->cipher.enc == 0) {
 121                return wc_MxcCb_AesEcbDecrypt(info->cipher.aesecb.aes,
 122                                                info->cipher.aesecb.out,
 123                                                info->cipher.aesecb.in,
 124                                                info->cipher.aesecb.sz);
 125                }
 126            #endif
 127            break; /* Break out and return error */
 128#endif
 129        default:
 130            /* Is not ECB/CBC/GCM */
 131            return WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 132    }
 133    /* Just in case code breaks of switch statement return error */
 134    return BAD_FUNC_ARG;
 135}
 136
 137#ifdef MAX3266X_SHA_CB
 138
 139/* Shared callback handler: Update grows buffer, Final computes hash. */
 140static int wc_MxcShaCbDispatch(byte** msg, word32* used, word32* len,
 141                                void* heap, const byte* in, word32 inSz,
 142                                byte* digest, MXC_TPU_HASH_TYPE algo)
 143{
 144    if (in != NULL && digest == NULL) {
 145        MAX3266X_MSG("Update CB");
 146        return _wc_Hash_Grow(msg, used, len, in, (int)inSz, heap);
 147    }
 148    if (in == NULL && digest != NULL) {
 149        MAX3266X_MSG("Final CB");
 150        return wc_MXC_TPU_SHA_Final(msg, used, len, heap, digest, algo);
 151    }
 152    if (inSz == 0) {
 153        return 0; /* Don't need to Update when Size is Zero */
 154    }
 155    return BAD_FUNC_ARG;
 156}
 157
 158int wc_MxcShaCryptoCb(wc_CryptoInfo* info)
 159{
 160    switch (info->hash.type) {
 161    #ifndef NO_SHA
 162        case WC_HASH_TYPE_SHA:
 163            return wc_MxcShaCbDispatch(&info->hash.sha1->msg,
 164                        &info->hash.sha1->used, &info->hash.sha1->len,
 165                        info->hash.sha1->heap, info->hash.in,
 166                        info->hash.inSz, info->hash.digest,
 167                        MXC_TPU_HASH_SHA1);
 168    #endif
 169    #ifdef WOLFSSL_SHA224
 170        case WC_HASH_TYPE_SHA224:
 171            return wc_MxcShaCbDispatch(&info->hash.sha224->msg,
 172                        &info->hash.sha224->used, &info->hash.sha224->len,
 173                        info->hash.sha224->heap, info->hash.in,
 174                        info->hash.inSz, info->hash.digest,
 175                        MXC_TPU_HASH_SHA224);
 176    #endif
 177    #ifndef NO_SHA256
 178        case WC_HASH_TYPE_SHA256:
 179            return wc_MxcShaCbDispatch(&info->hash.sha256->msg,
 180                        &info->hash.sha256->used, &info->hash.sha256->len,
 181                        info->hash.sha256->heap, info->hash.in,
 182                        info->hash.inSz, info->hash.digest,
 183                        MXC_TPU_HASH_SHA256);
 184    #endif
 185    #ifdef WOLFSSL_SHA384
 186        case WC_HASH_TYPE_SHA384:
 187            return wc_MxcShaCbDispatch(&info->hash.sha384->msg,
 188                        &info->hash.sha384->used, &info->hash.sha384->len,
 189                        info->hash.sha384->heap, info->hash.in,
 190                        info->hash.inSz, info->hash.digest,
 191                        MXC_TPU_HASH_SHA384);
 192    #endif
 193    #ifdef WOLFSSL_SHA512
 194        case WC_HASH_TYPE_SHA512:
 195            return wc_MxcShaCbDispatch(&info->hash.sha512->msg,
 196                        &info->hash.sha512->used, &info->hash.sha512->len,
 197                        info->hash.sha512->heap, info->hash.in,
 198                        info->hash.inSz, info->hash.digest,
 199                        MXC_TPU_HASH_SHA512);
 200    #endif
 201        default:
 202            return WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 203    }
 204}
 205#endif /* MAX3266X_SHA_CB */
 206
 207#ifdef WOLF_CRYPTO_CB_COPY
 208static int wc_MxcCopyCb(wc_CryptoInfo* info)
 209{
 210    if (info == NULL || info->copy.src == NULL || info->copy.dst == NULL) {
 211        return BAD_FUNC_ARG;
 212    }
 213
 214    switch (info->copy.type) {
 215#ifdef MAX3266X_SHA_CB
 216    #ifndef NO_SHA
 217        case WC_HASH_TYPE_SHA:
 218            return wc_MXC_TPU_SHA_Copy(info->copy.src, info->copy.dst,
 219                        sizeof(wc_Sha),
 220                        &((wc_Sha*)info->copy.dst)->msg,
 221                        &((wc_Sha*)info->copy.dst)->used,
 222                        &((wc_Sha*)info->copy.dst)->len,
 223                        ((wc_Sha*)info->copy.dst)->heap,
 224                        ((wc_Sha*)info->copy.src)->heap);
 225    #endif
 226    #ifdef WOLFSSL_SHA224
 227        case WC_HASH_TYPE_SHA224:
 228            return wc_MXC_TPU_SHA_Copy(info->copy.src, info->copy.dst,
 229                        sizeof(wc_Sha224),
 230                        &((wc_Sha224*)info->copy.dst)->msg,
 231                        &((wc_Sha224*)info->copy.dst)->used,
 232                        &((wc_Sha224*)info->copy.dst)->len,
 233                        ((wc_Sha224*)info->copy.dst)->heap,
 234                        ((wc_Sha224*)info->copy.src)->heap);
 235    #endif
 236    #ifndef NO_SHA256
 237        case WC_HASH_TYPE_SHA256:
 238            return wc_MXC_TPU_SHA_Copy(info->copy.src, info->copy.dst,
 239                        sizeof(wc_Sha256),
 240                        &((wc_Sha256*)info->copy.dst)->msg,
 241                        &((wc_Sha256*)info->copy.dst)->used,
 242                        &((wc_Sha256*)info->copy.dst)->len,
 243                        ((wc_Sha256*)info->copy.dst)->heap,
 244                        ((wc_Sha256*)info->copy.src)->heap);
 245    #endif
 246    #ifdef WOLFSSL_SHA384
 247        case WC_HASH_TYPE_SHA384:
 248            return wc_MXC_TPU_SHA_Copy(info->copy.src, info->copy.dst,
 249                        sizeof(wc_Sha384),
 250                        &((wc_Sha384*)info->copy.dst)->msg,
 251                        &((wc_Sha384*)info->copy.dst)->used,
 252                        &((wc_Sha384*)info->copy.dst)->len,
 253                        ((wc_Sha384*)info->copy.dst)->heap,
 254                        ((wc_Sha384*)info->copy.src)->heap);
 255    #endif
 256    #ifdef WOLFSSL_SHA512
 257        case WC_HASH_TYPE_SHA512:
 258            return wc_MXC_TPU_SHA_Copy(info->copy.src, info->copy.dst,
 259                        sizeof(wc_Sha512),
 260                        &((wc_Sha512*)info->copy.dst)->msg,
 261                        &((wc_Sha512*)info->copy.dst)->used,
 262                        &((wc_Sha512*)info->copy.dst)->len,
 263                        ((wc_Sha512*)info->copy.dst)->heap,
 264                        ((wc_Sha512*)info->copy.src)->heap);
 265    #endif
 266#endif /* MAX3266X_SHA_CB */
 267        default:
 268            return WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 269    }
 270}
 271#endif /* WOLF_CRYPTO_CB_COPY */
 272
 273#ifdef WOLF_CRYPTO_CB_FREE
 274static int wc_MxcFreeCb(wc_CryptoInfo* info)
 275{
 276    if (info == NULL || info->free.obj == NULL) {
 277        return BAD_FUNC_ARG;
 278    }
 279
 280    switch (info->free.type) {
 281#ifdef MAX3266X_SHA_CB
 282    #ifndef NO_SHA
 283        case WC_HASH_TYPE_SHA:
 284            wc_MXC_TPU_SHA_FreeCtx(info->free.obj, sizeof(wc_Sha),
 285                        &((wc_Sha*)info->free.obj)->msg,
 286                        &((wc_Sha*)info->free.obj)->used,
 287                        &((wc_Sha*)info->free.obj)->len,
 288                        ((wc_Sha*)info->free.obj)->heap);
 289            return 0;
 290    #endif
 291    #ifdef WOLFSSL_SHA224
 292        case WC_HASH_TYPE_SHA224:
 293            wc_MXC_TPU_SHA_FreeCtx(info->free.obj, sizeof(wc_Sha224),
 294                        &((wc_Sha224*)info->free.obj)->msg,
 295                        &((wc_Sha224*)info->free.obj)->used,
 296                        &((wc_Sha224*)info->free.obj)->len,
 297                        ((wc_Sha224*)info->free.obj)->heap);
 298            return 0;
 299    #endif
 300    #ifndef NO_SHA256
 301        case WC_HASH_TYPE_SHA256:
 302            wc_MXC_TPU_SHA_FreeCtx(info->free.obj, sizeof(wc_Sha256),
 303                        &((wc_Sha256*)info->free.obj)->msg,
 304                        &((wc_Sha256*)info->free.obj)->used,
 305                        &((wc_Sha256*)info->free.obj)->len,
 306                        ((wc_Sha256*)info->free.obj)->heap);
 307            return 0;
 308    #endif
 309    #ifdef WOLFSSL_SHA384
 310        case WC_HASH_TYPE_SHA384:
 311            wc_MXC_TPU_SHA_FreeCtx(info->free.obj, sizeof(wc_Sha384),
 312                        &((wc_Sha384*)info->free.obj)->msg,
 313                        &((wc_Sha384*)info->free.obj)->used,
 314                        &((wc_Sha384*)info->free.obj)->len,
 315                        ((wc_Sha384*)info->free.obj)->heap);
 316            return 0;
 317    #endif
 318    #ifdef WOLFSSL_SHA512
 319        case WC_HASH_TYPE_SHA512:
 320            wc_MXC_TPU_SHA_FreeCtx(info->free.obj, sizeof(wc_Sha512),
 321                        &((wc_Sha512*)info->free.obj)->msg,
 322                        &((wc_Sha512*)info->free.obj)->used,
 323                        &((wc_Sha512*)info->free.obj)->len,
 324                        ((wc_Sha512*)info->free.obj)->heap);
 325            return 0;
 326    #endif
 327#endif /* MAX3266X_SHA_CB */
 328        default:
 329            return WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 330    }
 331}
 332#endif /* WOLF_CRYPTO_CB_FREE */
 333
 334/* General Callback Function to determine ALGO Type */
 335int wc_MxcCryptoCb(int devIdArg, wc_CryptoInfo* info, void* ctx)
 336{
 337    int ret;
 338    (void)ctx;
 339    (void)devIdArg;
 340
 341    if (info == NULL) {
 342        return BAD_FUNC_ARG;
 343    }
 344
 345#ifdef DEBUG_CRYPTOCB
 346    wc_CryptoCb_InfoString(info);
 347#endif
 348
 349    switch (info->algo_type) {
 350        case WC_ALGO_TYPE_CIPHER:
 351            MAX3266X_MSG("Using MXC AES HW Callback:");
 352            ret = wc_MxcAesCryptoCb(info); /* Determine AES HW or SW */
 353            break;
 354#ifdef MAX3266X_SHA_CB
 355        case WC_ALGO_TYPE_HASH:
 356            MAX3266X_MSG("Using MXC SHA HW Callback:");
 357            ret = wc_MxcShaCryptoCb(info); /* Determine SHA HW or SW */
 358            break;
 359#endif /* MAX3266X_SHA_CB */
 360#ifdef WOLF_CRYPTO_CB_COPY
 361        case WC_ALGO_TYPE_COPY:
 362            MAX3266X_MSG("Using MXC Copy Callback:");
 363            ret = wc_MxcCopyCb(info);
 364            break;
 365#endif /* WOLF_CRYPTO_CB_COPY */
 366#ifdef WOLF_CRYPTO_CB_FREE
 367        case WC_ALGO_TYPE_FREE:
 368            MAX3266X_MSG("Using MXC Free Callback:");
 369            ret = wc_MxcFreeCb(info);
 370            break;
 371#endif /* WOLF_CRYPTO_CB_FREE */
 372        default:
 373            MAX3266X_MSG("Callback not support with MXC, using SW");
 374            /* return this to bypass HW and use SW */
 375            ret = WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
 376    }
 377
 378    return ret;
 379}
 380#endif
 381
 382/* Convert Error Codes Correctly and Report HW error when */
 383/* using #define MAX3266X_VERBOSE */
 384int wc_MXC_error(int *ret)
 385{
 386    if (ret == NULL) {
 387        /* In case somehow pointer to the return code is NULL */
 388        return BAD_FUNC_ARG;
 389    }
 390    switch (*ret) {
 391        case E_SUCCESS:
 392            return 0;
 393
 394        case E_INVALID: /* Process Failed */
 395            MAX3266X_MSG("HW Reported: E_INVALID Error");
 396            *ret = WC_HW_E;
 397            break;
 398
 399        case E_NULL_PTR:
 400            MAX3266X_MSG("HW Reported: E_NULL_PTR Error");
 401            *ret = BAD_FUNC_ARG;
 402            break;
 403
 404        case E_BAD_PARAM:
 405            MAX3266X_MSG("HW Reported: E_BAD_PARAM Error");
 406            *ret = BAD_FUNC_ARG;
 407            break;
 408
 409        case E_BAD_STATE:
 410            MAX3266X_MSG("HW Reported: E_BAD_STATE Error");
 411            *ret = WC_HW_E;
 412            break;
 413
 414        default:
 415            MAX3266X_MSG("HW Reported an Unknown Error");
 416            *ret = WC_HW_E; /* If something else return HW Error */
 417            break;
 418    }
 419    return *ret;
 420}
 421
 422
 423#if defined(MAX3266X_RNG)
 424/* Simple call to SDK's TRNG HW */
 425int wc_MXC_TRNG_Random(unsigned char* output, unsigned int sz)
 426{
 427    int status;
 428    if (output == NULL) {
 429        return BAD_FUNC_ARG;
 430    }
 431    status = wolfSSL_HwRngMutexLock(); /* Lock Mutex needed since */
 432                                         /* calling TPU init */
 433    if (status != 0) {
 434        return status;
 435    }
 436    status = MXC_TPU_Init(MXC_SYS_PERIPH_CLOCK_TRNG);
 437    if (status == 0) {
 438        /* void return function */
 439        MXC_TPU_TRNG_Read(MXC_TRNG, output, sz);
 440        MAX3266X_MSG("TRNG Hardware Used");
 441    }
 442    else {
 443        MAX3266X_MSG("TRNG Device did not initialize");
 444        status = RNG_FAILURE_E;
 445    }
 446    wolfSSL_HwRngMutexUnLock(); /* Unlock Mutex no matter status value */
 447    return status;
 448}
 449#endif /* MAX3266X_RNG */
 450
 451#if defined(MAX3266X_AES)
 452/* Generic call to the SDK's AES 1 shot Encrypt based on inputs given */
 453int wc_MXC_TPU_AesEncrypt(const unsigned char* in, const unsigned char* iv,
 454                            const unsigned char* enc_key,
 455                            MXC_TPU_MODE_TYPE mode, unsigned int data_size,
 456                            unsigned char* out, unsigned int keySize)
 457{
 458    int status;
 459    if (in == NULL || iv == NULL || enc_key == NULL || out == NULL) {
 460        return BAD_FUNC_ARG;
 461    }
 462    status = wolfSSL_HwAesMutexLock();
 463    MAX3266X_MSG("AES HW Encryption");
 464    if (status != 0) {
 465        MAX3266X_MSG("Hardware Mutex Failure");
 466        return status;
 467    }
 468    switch (keySize) {
 469        case MXC_AES_KEY_128_LEN:
 470            MXC_TPU_Cipher_Config(mode, MXC_TPU_CIPHER_AES128);
 471            status = MXC_TPU_Cipher_AES_Encrypt((const char*)in,
 472                        (const char*)iv, (const char*)enc_key,
 473                        MXC_TPU_CIPHER_AES128, mode, data_size, (char*)out);
 474            MAX3266X_MSG("AES HW Acceleration Used: 128 Bit");
 475            break;
 476        case MXC_AES_KEY_192_LEN:
 477            MXC_TPU_Cipher_Config(mode, MXC_TPU_CIPHER_AES192);
 478            status = MXC_TPU_Cipher_AES_Encrypt((const char*)in,
 479                        (const char*)iv, (const char*)enc_key,
 480                        MXC_TPU_CIPHER_AES192, mode, data_size, (char*)out);
 481            MAX3266X_MSG("AES HW Acceleration Used: 192 Bit");
 482            break;
 483        case MXC_AES_KEY_256_LEN:
 484            MXC_TPU_Cipher_Config(mode, MXC_TPU_CIPHER_AES256);
 485            status = MXC_TPU_Cipher_AES_Encrypt((const char*)in,
 486                        (const char*)iv, (const char*)enc_key,
 487                        MXC_TPU_CIPHER_AES256, mode, data_size, (char*)out);
 488            MAX3266X_MSG("AES HW Acceleration Used: 256 Bit");
 489            break;
 490        default:
 491            MAX3266X_MSG("AES HW ERROR: Length Not Supported");
 492            wolfSSL_HwAesMutexUnLock();
 493            return BAD_FUNC_ARG;
 494    }
 495    wolfSSL_HwAesMutexUnLock();
 496    if (status != 0) {
 497        MAX3266X_MSG("AES HW Acceleration Error Occurred");
 498        return WC_HW_E;
 499    }
 500    return status;
 501}
 502
 503
 504/* Encrypt AES Crypto Callbacks*/
 505#if defined(WOLF_CRYPTO_CB)
 506
 507#ifdef HAVE_AES_ECB
 508int wc_MxcCb_AesEcbEncrypt(Aes* aes, byte* out, const byte* in, word32 sz)
 509{
 510    int status;
 511    word32 keySize;
 512
 513    if ((in == NULL) || (out == NULL) || (aes == NULL)) {
 514        return BAD_FUNC_ARG;
 515    }
 516
 517    status = wc_AesGetKeySize(aes, &keySize);
 518    if (status != 0) {
 519        return status;
 520    }
 521
 522    status = wc_MXC_TPU_AesEncrypt(in, (byte*)aes->reg, (byte*)aes->devKey,
 523                                        MXC_TPU_MODE_ECB, sz, out, keySize);
 524
 525    return status;
 526}
 527#endif /* HAVE_AES_ECB */
 528
 529#ifdef HAVE_AES_CBC
 530int wc_MxcCb_AesCbcEncrypt(Aes* aes, byte* out, const byte* in, word32 sz)
 531{
 532    word32 keySize;
 533    int status;
 534    byte *iv;
 535
 536    if ((in == NULL) || (out == NULL) || (aes == NULL)) {
 537        return BAD_FUNC_ARG;
 538    }
 539
 540    /* Always enforce a length check */
 541    if (sz % WC_AES_BLOCK_SIZE) {
 542    #ifdef WOLFSSL_AES_CBC_LENGTH_CHECKS
 543        return BAD_LENGTH_E;
 544    #else
 545        return BAD_FUNC_ARG;
 546    #endif
 547    }
 548    if (sz == 0) {
 549        return 0;
 550    }
 551
 552    iv = (byte*)aes->reg;
 553    status = wc_AesGetKeySize(aes, &keySize);
 554    if (status != 0) {
 555        return status;
 556    }
 557
 558    status = wc_MXC_TPU_AesEncrypt(in, iv, (byte*)aes->devKey,
 559                                    MXC_TPU_MODE_CBC, sz, out,
 560                                    (unsigned int)keySize);
 561    /* store iv for next call */
 562    if (status == 0) {
 563        XMEMCPY(iv, out + sz - WC_AES_BLOCK_SIZE, WC_AES_BLOCK_SIZE);
 564    }
 565    return status;
 566}
 567#endif /* HAVE_AES_CBC */
 568#endif /* WOLF_CRYPTO_CB */
 569
 570#ifdef HAVE_AES_DECRYPT
 571/* Generic call to the SDK's AES 1 shot decrypt based on inputs given */
 572int wc_MXC_TPU_AesDecrypt(const unsigned char* in, const unsigned char* iv,
 573                            const unsigned char* dec_key,
 574                            MXC_TPU_MODE_TYPE mode, unsigned int data_size,
 575                            unsigned char* out, unsigned int keySize)
 576{
 577    int status;
 578    if (in == NULL || iv == NULL || dec_key == NULL || out == NULL) {
 579        return BAD_FUNC_ARG;
 580    }
 581    status = wolfSSL_HwAesMutexLock();
 582    if (status != 0) {
 583        return status;
 584    }
 585    switch (keySize) {
 586        case MXC_AES_KEY_128_LEN:
 587            MXC_TPU_Cipher_Config(mode, MXC_TPU_CIPHER_AES128);
 588            status = MXC_TPU_Cipher_AES_Decrypt((const char*)in,
 589                        (const char*)iv, (const char*)dec_key,
 590                        MXC_TPU_CIPHER_AES128, mode, data_size, (char*)out);
 591            MAX3266X_MSG("AES HW Acceleration Used: 128 Bit");
 592            break;
 593        case MXC_AES_KEY_192_LEN:
 594            MXC_TPU_Cipher_Config(mode, MXC_TPU_CIPHER_AES192);
 595            status = MXC_TPU_Cipher_AES_Decrypt((const char*)in,
 596                        (const char*)iv, (const char*)dec_key,
 597                        MXC_TPU_CIPHER_AES192, mode, data_size, (char*)out);
 598            MAX3266X_MSG("AES HW Acceleration Used: 192 Bit");
 599            break;
 600        case MXC_AES_KEY_256_LEN:
 601            MXC_TPU_Cipher_Config(mode, MXC_TPU_CIPHER_AES256);
 602            status = MXC_TPU_Cipher_AES_Decrypt((const char*)in,
 603                        (const char*)iv, (const char*)dec_key,
 604                        MXC_TPU_CIPHER_AES256, mode, data_size, (char*)out);
 605            MAX3266X_MSG("AES HW Acceleration Used: 256 Bit");
 606            break;
 607        default:
 608            MAX3266X_MSG("AES HW ERROR: Length Not Supported");
 609            wolfSSL_HwAesMutexUnLock();
 610            return BAD_FUNC_ARG;
 611    }
 612    wolfSSL_HwAesMutexUnLock();
 613    if (status != 0) {
 614        MAX3266X_MSG("AES HW Acceleration Error Occurred");
 615        return WC_HW_E;
 616    }
 617    return status;
 618}
 619
 620/* Decrypt Aes Crypto Callbacks*/
 621#if defined(WOLF_CRYPTO_CB)
 622
 623#ifdef HAVE_AES_ECB
 624int wc_MxcCb_AesEcbDecrypt(Aes* aes, byte* out, const byte* in, word32 sz)
 625{
 626    int status;
 627    word32 keySize;
 628
 629    if ((in == NULL) || (out == NULL) || (aes == NULL)) {
 630        return BAD_FUNC_ARG;
 631    }
 632
 633    status = wc_AesGetKeySize(aes, &keySize);
 634    if (status != 0) {
 635        return status;
 636    }
 637
 638    status = wc_MXC_TPU_AesDecrypt(in, (byte*)aes->reg, (byte*)aes->devKey,
 639                                        MXC_TPU_MODE_ECB, sz, out, keySize);
 640
 641    return status;
 642}
 643#endif /* HAVE_AES_ECB */
 644
 645#ifdef HAVE_AES_CBC
 646int wc_MxcCb_AesCbcDecrypt(Aes* aes, byte* out, const byte* in, word32 sz)
 647{
 648    word32 keySize;
 649    int status;
 650    byte *iv;
 651    byte temp_block[WC_AES_BLOCK_SIZE];
 652
 653    if ((in == NULL) || (out == NULL) || (aes == NULL)) {
 654        return BAD_FUNC_ARG;
 655    }
 656
 657    /* Always enforce a length check */
 658    if (sz % WC_AES_BLOCK_SIZE) {
 659    #ifdef WOLFSSL_AES_CBC_LENGTH_CHECKS
 660        return BAD_LENGTH_E;
 661    #else
 662        return BAD_FUNC_ARG;
 663    #endif
 664    }
 665    if (sz == 0) {
 666        return 0;
 667    }
 668
 669    iv = (byte*)aes->reg;
 670    status = wc_AesGetKeySize(aes, &keySize);
 671    if (status != 0) {
 672        return status;
 673    }
 674
 675    /* get IV for next call */
 676    XMEMCPY(temp_block, in + sz - WC_AES_BLOCK_SIZE, WC_AES_BLOCK_SIZE);
 677    status = wc_MXC_TPU_AesDecrypt(in, iv, (byte*)aes->devKey,
 678                                    MXC_TPU_MODE_CBC, sz, out,
 679                                    keySize);
 680
 681    /* store iv for next call */
 682    if (status == 0) {
 683        XMEMCPY(iv, temp_block, WC_AES_BLOCK_SIZE);
 684    }
 685    return status;
 686}
 687#endif /* HAVE_AES_CBC */
 688#endif /* WOLF_CRYPTO_CB */
 689#endif /* HAVE_AES_DECRYPT */
 690#endif /* MAX3266X_AES */
 691
 692#if defined(MAX3266X_SHA) || defined(MAX3266X_SHA_CB)
 693
 694/* Check for empty message and provide pre-computed digest if so */
 695/* Returns 1 if empty (digest filled), 0 if needs hardware processing */
 696int wc_MXC_TPU_SHA_GetDigest(const unsigned char* msg, unsigned int msgSz,
 697                                        unsigned char* digest,
 698                                        MXC_TPU_HASH_TYPE algo)
 699{
 700    if (digest == NULL) {
 701        return BAD_FUNC_ARG;
 702    }
 703    if (msg == NULL && msgSz == 0) {
 704        switch (algo) {
 705            #ifndef NO_SHA
 706            case MXC_TPU_HASH_SHA1:
 707                XMEMCPY(digest, MXC_EMPTY_DIGEST_SHA1, WC_SHA_DIGEST_SIZE);
 708                break;
 709            #endif /* NO_SHA */
 710            #ifdef WOLFSSL_SHA224
 711            case MXC_TPU_HASH_SHA224:
 712                XMEMCPY(digest, MXC_EMPTY_DIGEST_SHA224, WC_SHA224_DIGEST_SIZE);
 713                break;
 714            #endif /* WOLFSSL_SHA224 */
 715            #ifndef NO_SHA256
 716            case MXC_TPU_HASH_SHA256:
 717                XMEMCPY(digest, MXC_EMPTY_DIGEST_SHA256, WC_SHA256_DIGEST_SIZE);
 718                break;
 719            #endif /* NO_SHA256 */
 720            #ifdef WOLFSSL_SHA384
 721            case MXC_TPU_HASH_SHA384:
 722                XMEMCPY(digest, MXC_EMPTY_DIGEST_SHA384, WC_SHA384_DIGEST_SIZE);
 723                break;
 724            #endif /* WOLFSSL_SHA384 */
 725            #ifdef WOLFSSL_SHA512
 726            case MXC_TPU_HASH_SHA512:
 727                XMEMCPY(digest, MXC_EMPTY_DIGEST_SHA512, WC_SHA512_DIGEST_SIZE);
 728                break;
 729            #endif /* WOLFSSL_SHA512 */
 730            default:
 731                return BAD_FUNC_ARG;
 732        }
 733        return 1; /* True: empty digest provided */
 734    }
 735    return 0; /* False: needs hardware processing */
 736}
 737
 738/* Compute hash from accumulated message using TPU hardware */
 739int wc_MXC_TPU_SHA_GetHash(const unsigned char* msg, unsigned int msgSz,
 740                                unsigned char* digest,
 741                                MXC_TPU_HASH_TYPE algo)
 742{
 743    int status;
 744    if (digest == NULL || (msg == NULL && msgSz != 0)) {
 745        return BAD_FUNC_ARG;
 746    }
 747    status = wc_MXC_TPU_SHA_GetDigest(msg, msgSz, digest, algo);
 748    /* True Case that msg is an empty string */
 749    if (status == 1) {
 750        /* Hardware cannot handle the case of an empty string */
 751        /* so in the case of this we will provide the hash via software */
 752        return 0;
 753    }
 754    /* False Case where msg needs to be processed */
 755    else if (status == 0) {
 756        status = wolfSSL_HwHashMutexLock(); /* Set Mutex */
 757        if (status != 0) { /* Mutex Call Check */
 758            return status;
 759        }
 760        MXC_TPU_Init(MXC_SYS_PERIPH_CLOCK_TPU);
 761        MXC_TPU_Hash_Config(algo);
 762        status = MXC_TPU_Hash_SHA((const char *)msg, algo, msgSz,
 763                                         (char *)digest);
 764        MAX3266X_MSG("SHA HW Acceleration Used");
 765        wolfSSL_HwHashMutexUnLock(); /* Release Mutex */
 766        if (wc_MXC_error(&status) != 0) {
 767            MAX3266X_MSG("SHA HW Error Occurred");
 768            return status;
 769        }
 770    }
 771    /* Error Occurred */
 772    return status;
 773}
 774
 775/* Free HASH_KEEP message buffer and reset fields */
 776void wc_MXC_TPU_SHA_Free(byte** msg, word32* used, word32* len, void* heap)
 777{
 778    if (msg == NULL) {
 779        return;
 780    }
 781    if (*msg != NULL) {
 782        XFREE(*msg, heap, DYNAMIC_TYPE_TMP_BUFFER);
 783        *msg = NULL;
 784    }
 785    if (used != NULL) {
 786        *used = 0;
 787    }
 788    if (len != NULL) {
 789        *len = 0;
 790    }
 791}
 792
 793/* Free HASH_KEEP message buffer and zero the full SHA context struct */
 794void wc_MXC_TPU_SHA_FreeCtx(void* ctx, word32 ctxSz, byte** msg, word32* used,
 795                                word32* len, void* heap)
 796{
 797    if (ctx == NULL) {
 798        return;
 799    }
 800    wc_MXC_TPU_SHA_Free(msg, used, len, heap);
 801    XMEMSET(ctx, 0, ctxSz);
 802}
 803
 804/* Copy SHA context struct and deep copy the HASH_KEEP message buffer.
 805 * Frees any existing dst msg buffer to prevent memory leaks when copying
 806 * into an already-used context. */
 807int wc_MXC_TPU_SHA_Copy(void* src, void* dst, word32 ctxSz,
 808                                byte** dstMsg, word32* dstUsed, word32* dstLen,
 809                                void* dstHeap, void* srcHeap)
 810{
 811    byte* srcBuf = NULL;
 812
 813    if (src == NULL || dst == NULL || dstMsg == NULL ||
 814        dstUsed == NULL || dstLen == NULL || ctxSz == 0) {
 815        return BAD_FUNC_ARG;
 816    }
 817
 818    /* Free existing dst msg buffer using dst's original heap */
 819    wc_MXC_TPU_SHA_Free(dstMsg, dstUsed, dstLen, dstHeap);
 820
 821    /* Shallow copy the full context struct */
 822    XMEMCPY(dst, src, ctxSz);
 823
 824    /* Deep copy src msg buffer if present. Since dstMsg points into the dst
 825     * struct, the XMEMCPY above overwrites it with the src's msg pointer.
 826     * Save that pointer, allocate a new buffer for dst, and copy the data.
 827     * Do NOT move srcBuf assignment before XMEMCPY - it must capture the
 828     * src msg pointer that lands in *dstMsg after the shallow copy. */
 829    if (*dstMsg != NULL) {
 830        srcBuf = *dstMsg;
 831        *dstMsg = (byte*)XMALLOC(*dstLen, srcHeap, DYNAMIC_TYPE_TMP_BUFFER);
 832        if (*dstMsg == NULL) {
 833            return MEMORY_E;
 834        }
 835        XMEMCPY(*dstMsg, srcBuf, *dstUsed);
 836    }
 837
 838    return 0;
 839}
 840
 841/* Compute hash, free message buffer, and reset HASH_KEEP fields */
 842int wc_MXC_TPU_SHA_Final(unsigned char** msg, unsigned int* used,
 843                                    unsigned int* len, void* heap,
 844                                    unsigned char* digest,
 845                                    MXC_TPU_HASH_TYPE algo)
 846{
 847    int status;
 848    if (msg == NULL || used == NULL || len == NULL || digest == NULL) {
 849        return BAD_FUNC_ARG;
 850    }
 851    status = wc_MXC_TPU_SHA_GetHash(*msg, *used, digest, algo);
 852    wc_MXC_TPU_SHA_Free(msg, used, len, heap);
 853    return status;
 854}
 855
 856#ifndef MAX3266X_SHA_CB
 857#if !defined(NO_SHA)
 858
 859WOLFSSL_API int wc_InitSha_ex(wc_Sha* sha, void* heap, int devId)
 860{
 861    if (sha == NULL) {
 862        return BAD_FUNC_ARG;
 863    }
 864    (void)devId;
 865    XMEMSET(sha, 0, sizeof(*sha));
 866    sha->heap = heap;
 867    return 0;
 868}
 869
 870WOLFSSL_API int wc_ShaUpdate(wc_Sha* sha, const unsigned char* data,
 871                                        unsigned int len)
 872{
 873    if (sha == NULL || (data == NULL && len > 0)) {
 874        return BAD_FUNC_ARG;
 875    }
 876    return _wc_Hash_Grow(&sha->msg, &sha->used, &sha->len,
 877                                        data, (int)len, sha->heap);
 878}
 879
 880WOLFSSL_API int wc_ShaFinal(wc_Sha* sha, unsigned char* hash)
 881{
 882    if (sha == NULL || hash == NULL) {
 883        return BAD_FUNC_ARG;
 884    }
 885    return wc_MXC_TPU_SHA_Final(&sha->msg, &sha->used, &sha->len,
 886                                        sha->heap, hash, MXC_TPU_HASH_SHA1);
 887}
 888
 889WOLFSSL_API int wc_ShaGetHash(wc_Sha* sha, unsigned char* hash)
 890{
 891    if (sha == NULL || hash == NULL) {
 892        return BAD_FUNC_ARG;
 893    }
 894    return wc_MXC_TPU_SHA_GetHash((const unsigned char*)sha->msg,
 895                                        sha->used, hash, MXC_TPU_HASH_SHA1);
 896}
 897
 898WOLFSSL_API int wc_ShaCopy(wc_Sha* src, wc_Sha* dst)
 899{
 900    if (src == NULL || dst == NULL) {
 901        return BAD_FUNC_ARG;
 902    }
 903    return wc_MXC_TPU_SHA_Copy(src, dst, sizeof(wc_Sha),
 904                                        &dst->msg, &dst->used, &dst->len,
 905                                        dst->heap, src->heap);
 906}
 907
 908WOLFSSL_API void wc_ShaFree(wc_Sha* sha)
 909{
 910    if (sha == NULL) {
 911        return;
 912    }
 913    wc_MXC_TPU_SHA_FreeCtx(sha, sizeof(wc_Sha), &sha->msg, &sha->used,
 914                                        &sha->len, sha->heap);
 915}
 916
 917#endif /* NO_SHA */
 918
 919#if defined(WOLFSSL_SHA224)
 920
 921WOLFSSL_API int wc_InitSha224_ex(wc_Sha224* sha224, void* heap, int devId)
 922{
 923    if (sha224 == NULL) {
 924        return BAD_FUNC_ARG;
 925    }
 926    (void)devId;
 927    XMEMSET(sha224, 0, sizeof(*sha224));
 928    sha224->heap = heap;
 929    return 0;
 930}
 931
 932WOLFSSL_API int wc_InitSha224(wc_Sha224* sha224)
 933{
 934    return wc_InitSha224_ex(sha224, NULL, INVALID_DEVID);
 935}
 936
 937WOLFSSL_API int wc_Sha224Update(wc_Sha224* sha224, const unsigned char* data,
 938                                        unsigned int len)
 939{
 940    if (sha224 == NULL || (data == NULL && len > 0)) {
 941        return BAD_FUNC_ARG;
 942    }
 943    return _wc_Hash_Grow(&sha224->msg, &sha224->used, &sha224->len,
 944                                        data, (int)len, sha224->heap);
 945}
 946
 947WOLFSSL_API int wc_Sha224Final(wc_Sha224* sha224, unsigned char* hash)
 948{
 949    if (sha224 == NULL || hash == NULL) {
 950        return BAD_FUNC_ARG;
 951    }
 952    return wc_MXC_TPU_SHA_Final(&sha224->msg, &sha224->used, &sha224->len,
 953                                        sha224->heap, hash,
 954                                        MXC_TPU_HASH_SHA224);
 955}
 956
 957WOLFSSL_API int wc_Sha224GetHash(wc_Sha224* sha224, unsigned char* hash)
 958{
 959    if (sha224 == NULL || hash == NULL) {
 960        return BAD_FUNC_ARG;
 961    }
 962    return wc_MXC_TPU_SHA_GetHash((const unsigned char*)sha224->msg,
 963                                        sha224->used, hash,
 964                                        MXC_TPU_HASH_SHA224);
 965}
 966
 967WOLFSSL_API int wc_Sha224Copy(wc_Sha224* src, wc_Sha224* dst)
 968{
 969    if (src == NULL || dst == NULL) {
 970        return BAD_FUNC_ARG;
 971    }
 972    return wc_MXC_TPU_SHA_Copy(src, dst, sizeof(wc_Sha224),
 973                                        &dst->msg, &dst->used, &dst->len,
 974                                        dst->heap, src->heap);
 975}
 976
 977WOLFSSL_API void wc_Sha224Free(wc_Sha224* sha224)
 978{
 979    if (sha224 == NULL) {
 980        return;
 981    }
 982    wc_MXC_TPU_SHA_FreeCtx(sha224, sizeof(wc_Sha224), &sha224->msg,
 983                                        &sha224->used, &sha224->len,
 984                                        sha224->heap);
 985}
 986
 987#endif /* WOLFSSL_SHA224 */
 988
 989#if !defined(NO_SHA256)
 990
 991WOLFSSL_API int wc_InitSha256_ex(wc_Sha256* sha256, void* heap, int devId)
 992{
 993    if (sha256 == NULL) {
 994        return BAD_FUNC_ARG;
 995    }
 996    (void)devId;
 997    XMEMSET(sha256, 0, sizeof(*sha256));
 998    sha256->heap = heap;
 999    return 0;
1000}
1001
1002WOLFSSL_API int wc_InitSha256(wc_Sha256* sha256)
1003{
1004    return wc_InitSha256_ex(sha256, NULL, INVALID_DEVID);
1005}
1006
1007WOLFSSL_API int wc_Sha256Update(wc_Sha256* sha256, const unsigned char* data,
1008                                        unsigned int len)
1009{
1010    if (sha256 == NULL || (data == NULL && len > 0)) {
1011        return BAD_FUNC_ARG;
1012    }
1013    return _wc_Hash_Grow(&sha256->msg, &sha256->used, &sha256->len,
1014                                        data, (int)len, sha256->heap);
1015}
1016
1017WOLFSSL_API int wc_Sha256Final(wc_Sha256* sha256, unsigned char* hash)
1018{
1019    if (sha256 == NULL || hash == NULL) {
1020        return BAD_FUNC_ARG;
1021    }
1022    return wc_MXC_TPU_SHA_Final(&sha256->msg, &sha256->used, &sha256->len,
1023                                        sha256->heap, hash,
1024                                        MXC_TPU_HASH_SHA256);
1025}
1026
1027WOLFSSL_API int wc_Sha256GetHash(wc_Sha256* sha256, unsigned char* hash)
1028{
1029    if (sha256 == NULL || hash == NULL) {
1030        return BAD_FUNC_ARG;
1031    }
1032    return wc_MXC_TPU_SHA_GetHash((const unsigned char*)sha256->msg,
1033                                        sha256->used, hash,
1034                                        MXC_TPU_HASH_SHA256);
1035}
1036
1037WOLFSSL_API int wc_Sha256Copy(wc_Sha256* src, wc_Sha256* dst)
1038{
1039    if (src == NULL || dst == NULL) {
1040        return BAD_FUNC_ARG;
1041    }
1042    return wc_MXC_TPU_SHA_Copy(src, dst, sizeof(wc_Sha256),
1043                                        &dst->msg, &dst->used, &dst->len,
1044                                        dst->heap, src->heap);
1045}
1046
1047WOLFSSL_API void wc_Sha256Free(wc_Sha256* sha256)
1048{
1049    if (sha256 == NULL) {
1050        return;
1051    }
1052    wc_MXC_TPU_SHA_FreeCtx(sha256, sizeof(wc_Sha256), &sha256->msg,
1053                                        &sha256->used, &sha256->len,
1054                                        sha256->heap);
1055}
1056
1057#endif /* NO_SHA256 */
1058
1059#if defined(WOLFSSL_SHA384)
1060
1061WOLFSSL_API int wc_InitSha384_ex(wc_Sha384* sha384, void* heap, int devId)
1062{
1063    if (sha384 == NULL) {
1064        return BAD_FUNC_ARG;
1065    }
1066    (void)devId;
1067    XMEMSET(sha384, 0, sizeof(*sha384));
1068    sha384->heap = heap;
1069    return 0;
1070}
1071
1072WOLFSSL_API int wc_InitSha384(wc_Sha384* sha384)
1073{
1074    return wc_InitSha384_ex(sha384, NULL, INVALID_DEVID);
1075}
1076
1077WOLFSSL_API int wc_Sha384Update(wc_Sha384* sha384, const unsigned char* data,
1078                                        unsigned int len)
1079{
1080    if (sha384 == NULL || (data == NULL && len > 0)) {
1081        return BAD_FUNC_ARG;
1082    }
1083    return _wc_Hash_Grow(&sha384->msg, &sha384->used, &sha384->len,
1084                                        data, (int)len, sha384->heap);
1085}
1086
1087WOLFSSL_API int wc_Sha384Final(wc_Sha384* sha384, unsigned char* hash)
1088{
1089    if (sha384 == NULL || hash == NULL) {
1090        return BAD_FUNC_ARG;
1091    }
1092    return wc_MXC_TPU_SHA_Final(&sha384->msg, &sha384->used, &sha384->len,
1093                                        sha384->heap, hash,
1094                                        MXC_TPU_HASH_SHA384);
1095}
1096
1097WOLFSSL_API int wc_Sha384GetHash(wc_Sha384* sha384, unsigned char* hash)
1098{
1099    if (sha384 == NULL || hash == NULL) {
1100        return BAD_FUNC_ARG;
1101    }
1102    return wc_MXC_TPU_SHA_GetHash((const unsigned char*)sha384->msg,
1103                                        sha384->used, hash,
1104                                        MXC_TPU_HASH_SHA384);
1105}
1106
1107WOLFSSL_API int wc_Sha384Copy(wc_Sha384* src, wc_Sha384* dst)
1108{
1109    if (src == NULL || dst == NULL) {
1110        return BAD_FUNC_ARG;
1111    }
1112    return wc_MXC_TPU_SHA_Copy(src, dst, sizeof(wc_Sha384),
1113                                        &dst->msg, &dst->used, &dst->len,
1114                                        dst->heap, src->heap);
1115}
1116
1117WOLFSSL_API void wc_Sha384Free(wc_Sha384* sha384)
1118{
1119    if (sha384 == NULL) {
1120        return;
1121    }
1122    wc_MXC_TPU_SHA_FreeCtx(sha384, sizeof(wc_Sha384), &sha384->msg,
1123                                        &sha384->used, &sha384->len,
1124                                        sha384->heap);
1125}
1126
1127#endif /* WOLFSSL_SHA384 */
1128
1129#if defined(WOLFSSL_SHA512)
1130
1131WOLFSSL_API int wc_InitSha512_ex(wc_Sha512* sha512, void* heap, int devId)
1132{
1133    if (sha512 == NULL) {
1134        return BAD_FUNC_ARG;
1135    }
1136    (void)devId;
1137    XMEMSET(sha512, 0, sizeof(*sha512));
1138    sha512->heap = heap;
1139#if defined(WOLFSSL_SHA512_HASHTYPE)
1140    sha512->hashType = WC_HASH_TYPE_SHA512;
1141#endif
1142    return 0;
1143}
1144
1145WOLFSSL_API int wc_InitSha512(wc_Sha512* sha512)
1146{
1147    return wc_InitSha512_ex(sha512, NULL, INVALID_DEVID);
1148}
1149
1150WOLFSSL_API int wc_Sha512Update(wc_Sha512* sha512, const unsigned char* data,
1151                                        unsigned int len)
1152{
1153    if (sha512 == NULL || (data == NULL && len > 0)) {
1154        return BAD_FUNC_ARG;
1155    }
1156    return _wc_Hash_Grow(&sha512->msg, &sha512->used, &sha512->len,
1157                                        data, (int)len, sha512->heap);
1158}
1159
1160WOLFSSL_API int wc_Sha512Final(wc_Sha512* sha512, unsigned char* hash)
1161{
1162    if (sha512 == NULL || hash == NULL) {
1163        return BAD_FUNC_ARG;
1164    }
1165    return wc_MXC_TPU_SHA_Final(&sha512->msg, &sha512->used, &sha512->len,
1166                                        sha512->heap, hash,
1167                                        MXC_TPU_HASH_SHA512);
1168}
1169
1170WOLFSSL_API int wc_Sha512GetHash(wc_Sha512* sha512, unsigned char* hash)
1171{
1172    if (sha512 == NULL || hash == NULL) {
1173        return BAD_FUNC_ARG;
1174    }
1175    return wc_MXC_TPU_SHA_GetHash((const unsigned char*)sha512->msg,
1176                                        sha512->used, hash,
1177                                        MXC_TPU_HASH_SHA512);
1178}
1179
1180WOLFSSL_API int wc_Sha512Copy(wc_Sha512* src, wc_Sha512* dst)
1181{
1182    if (src == NULL || dst == NULL) {
1183        return BAD_FUNC_ARG;
1184    }
1185    return wc_MXC_TPU_SHA_Copy(src, dst, sizeof(wc_Sha512),
1186                                        &dst->msg, &dst->used, &dst->len,
1187                                        dst->heap, src->heap);
1188}
1189
1190WOLFSSL_API void wc_Sha512Free(wc_Sha512* sha512)
1191{
1192    if (sha512 == NULL) {
1193        return;
1194    }
1195    wc_MXC_TPU_SHA_FreeCtx(sha512, sizeof(wc_Sha512), &sha512->msg,
1196                                        &sha512->used, &sha512->len,
1197                                        sha512->heap);
1198}
1199
1200#endif /* WOLFSSL_SHA512 */
1201#endif /* !MAX3266X_SHA_CB*/
1202#endif /* MAX3266X_SHA || MAX3266X_SHA_CB */
1203
1204#if defined(MAX3266X_MATH)
1205
1206/* Sets mutex and initializes hardware according to needed operation size */
1207int wc_MXC_MAA_init(unsigned int len)
1208{
1209    int status;
1210    MAX3266X_MSG("Setting Hardware Mutex and Starting MAA");
1211    status = wolfSSL_HwPkMutexLock();
1212    if (status == 0) {
1213        status = MXC_TPU_MAA_Init(len);
1214    }
1215    return wc_MXC_error(&status); /* Return Status of Init */
1216}
1217
1218/* Unlocks mutex and performs graceful shutdown of hardware */
1219int wc_MXC_MAA_Shutdown(void)
1220{
1221    int status;
1222    MAX3266X_MSG("Unlocking Hardware Mutex and Shutting Down MAA");
1223    status = MXC_TPU_MAA_Shutdown();
1224    if (status == E_BAD_PARAM) { /* Miss leading, Send WC_HW_ERROR */
1225                                /* This is returned when MAA cannot stop */
1226        status = WC_HW_E;
1227    }
1228    wolfSSL_HwPkMutexUnLock(); /* Always call Unlock in shutdown */
1229    return wc_MXC_error(&status);
1230}
1231
1232/* Update used number for mp_int struct for results */
1233int wc_MXC_MAA_adjustUsed(unsigned int *array, unsigned int length)
1234{
1235    int i, lastNonZeroIndex;
1236    lastNonZeroIndex = -1; /* Track the last non-zero index */
1237    for (i = 0; i < length; i++) {
1238        if (array[i] != 0) {
1239            lastNonZeroIndex = i;
1240        }
1241    }
1242    return (lastNonZeroIndex + 1);
1243}
1244
1245/* Determines the size of operation that needs to happen */
1246unsigned int wc_MXC_MAA_Largest(unsigned int count, ...)
1247{
1248    va_list args;
1249    int i;
1250    unsigned int largest, num;
1251    va_start(args, count);
1252    largest = va_arg(args, unsigned int);
1253    for (i = 1; i < count; i++) {
1254        num = va_arg(args, unsigned int);
1255        if (num > largest) {
1256            largest = num;
1257        }
1258    }
1259    va_end(args);
1260    return largest;
1261}
1262
1263/* Determines if we need to fallback to Software */
1264int wc_MXC_MAA_Fallback(unsigned int count, ...)
1265{
1266    va_list args;
1267    int num, i;
1268    va_start(args, count);
1269    for (i = 0; i < count; i++) {
1270        num = va_arg(args, unsigned int);
1271        if (num > MXC_MAA_MAX_SIZE) {
1272            MAX3266X_MSG("HW Falling Back to Software");
1273            return 1;
1274        }
1275    }
1276    va_end(args);
1277    MAX3266X_MSG("HW Can Handle Input");
1278    return 0;
1279}
1280
1281/* Have to zero pad the entire data array up to 256 bytes(2048 bits) */
1282/* If length > 256 bytes then error */
1283int wc_MXC_MAA_zeroPad(mp_int* multiplier, mp_int* multiplicand,
1284                            mp_int* exp, mp_int* mod, mp_int* result,
1285                            MXC_TPU_MAA_TYPE clc, unsigned int length)
1286{
1287    mp_digit* zero_tmp;
1288    MAX3266X_MSG("Zero Padding Buffers for Hardware");
1289    if (length > MXC_MAA_MAX_SIZE) {
1290        MAX3266X_MSG("Hardware cannot exceed 2048 bit input");
1291        return BAD_FUNC_ARG;
1292    }
1293    if ((result == NULL) || (multiplier == NULL) || (multiplicand == NULL) ||
1294            ((exp == NULL) && (clc == MXC_TPU_MAA_EXP)) || (mod == NULL)) {
1295        return BAD_FUNC_ARG;
1296    }
1297
1298    /* Create an array to compare values to to check edge for error edge case */
1299    zero_tmp = (mp_digit*)XMALLOC(multiplier->size*sizeof(mp_digit), NULL,
1300                                    DYNAMIC_TYPE_TMP_BUFFER);
1301    if (zero_tmp == NULL) {
1302        MAX3266X_MSG("NULL pointer found after XMALLOC call");
1303        return MEMORY_E;
1304    }
1305    XMEMSET(zero_tmp, 0x00, multiplier->size*sizeof(mp_digit));
1306
1307    /* Check for invalid arguments before padding */
1308    switch ((char)clc) {
1309        case MXC_TPU_MAA_EXP:
1310            /* Cannot be 0 for a^e mod m operation */
1311            if (XMEMCMP(zero_tmp, exp, (exp->used*sizeof(mp_digit))) == 0) {
1312                XFREE(zero_tmp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1313                MAX3266X_MSG("Cannot use Value 0 for Exp");
1314                return BAD_FUNC_ARG;
1315            }
1316
1317            /* Pad out rest of data if used != length to ensure no */
1318            /* garbage is used in calculation */
1319            if ((exp != NULL) && (clc == MXC_TPU_MAA_EXP)) {
1320                if ((exp->dp != NULL) && (exp->used < length)) {
1321                    MAX3266X_MSG("Zero Padding Exp Buffer");
1322                    XMEMSET(exp->dp + exp->used, 0x00,
1323                            sizeof(int) *(length - exp->used));
1324                }
1325            }
1326
1327        /* Fall through to check mod is not 0 */
1328        case MXC_TPU_MAA_SQ:
1329        case MXC_TPU_MAA_MUL:
1330        case MXC_TPU_MAA_SQMUL:
1331        case MXC_TPU_MAA_ADD:
1332        case MXC_TPU_MAA_SUB:
1333            /* Cannot be 0 for mod m value */
1334            if (XMEMCMP(zero_tmp, mod, (exp->used*sizeof(mp_digit))) == 0) {
1335                XFREE(zero_tmp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1336                MAX3266X_MSG("Cannot use Value 0 for Exp");
1337                return BAD_FUNC_ARG;
1338            }
1339
1340            /* Pad out rest of data if used != length to ensure no */
1341            /* garbage is used in calculation */
1342            if ((multiplier->dp != NULL) && (multiplier->used < length)) {
1343                MAX3266X_MSG("Zero Padding Multiplier Buffer");
1344                XMEMSET(multiplier->dp + multiplier->used, 0x00,
1345                    sizeof(int) * (length - multiplier->used));
1346            }
1347            if ((multiplicand->dp != NULL) && (multiplicand->used < length)) {
1348                MAX3266X_MSG("Zero Padding Multiplicand Buffer");
1349                XMEMSET(multiplicand->dp + multiplicand->used, 0x00,
1350                    sizeof(int) * (length - multiplicand->used));
1351            }
1352            if ((mod->dp != NULL) && (mod->used < length)) {
1353                MAX3266X_MSG("Zero Padding Mod Buffer");
1354                XMEMSET(mod->dp + mod->used, 0x00,
1355                            sizeof(int) *(length - mod->used));
1356            }
1357            break;
1358        default:
1359            /* Free the zero array used to check values */
1360            XFREE(zero_tmp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1361            return BAD_FUNC_ARG; /* Invalid clc given */
1362    }
1363    /* Free the zero array used to check values */
1364    XFREE(zero_tmp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1365
1366    /* Make sure result is 0 padded */
1367    if (result->dp != NULL) {
1368        ForceZero(result->dp, sizeof(int)*(length));
1369        result->used = length;
1370    }
1371    return 0;
1372}
1373
1374
1375
1376/* General Control Over MAA Hardware to handle all needed Cases */
1377int wc_MXC_MAA_math(mp_int* multiplier, mp_int* multiplicand, mp_int* exp,
1378                                mp_int* mod, mp_int* result,
1379                                MXC_TPU_MAA_TYPE clc)
1380{
1381    int ret;
1382    int length;
1383    mp_int* result_tmp_ptr;
1384    mp_int result_tmp;
1385    if (multiplier == NULL || multiplicand == NULL || mod == NULL ||
1386            (exp == NULL && clc == MXC_TPU_MAA_EXP) || result == NULL) {
1387        return BAD_FUNC_ARG;
1388    }
1389
1390    /* Check if result shares struct pointer */
1391    if ((multiplier == result) || (multiplicand == result) || (exp == result) ||
1392            (mod == result)) {
1393            MAX3266X_MSG("Creating Temp Result Buffer for Hardware");
1394            result_tmp_ptr = &result_tmp; /* Assign point to temp struct */
1395    }
1396    else {
1397        result_tmp_ptr = result; /* No Shared Point to directly assign */
1398    }
1399    if (result_tmp_ptr == NULL) {
1400        MAX3266X_MSG("tmp ptr is null");
1401        return MP_VAL;
1402    }
1403
1404    if (clc == MXC_TPU_MAA_EXP) {
1405        length = wc_MXC_MAA_Largest(5, multiplier->used, multiplicand->used,
1406                                           exp->used, mod->used, result->used);
1407    }
1408    else {
1409        length = wc_MXC_MAA_Largest(4, multiplier->used, multiplicand->used,
1410                                        mod->used, result->used);
1411    }
1412
1413    /* Zero Pad everything if needed */
1414    ret = wc_MXC_MAA_zeroPad(multiplier, multiplicand, exp, mod, result_tmp_ptr,
1415                                clc, length);
1416    if (ret != 0) {
1417        MAX3266X_MSG("Zero Padding Failed");
1418        return ret;
1419    }
1420
1421    /* Init MAA HW */
1422    ret = wc_MXC_MAA_init(length*sizeof(mp_digit)*8);
1423    if (ret != 0) {
1424        MAX3266X_MSG("HW Init Failed");
1425        wolfSSL_HwPkMutexUnLock();
1426        return ret;
1427    }
1428
1429    /* Start Math And Cast to expect types for SDK */
1430    MAX3266X_MSG("Starting Computation in MAA");
1431    ret = MXC_TPU_MAA_Compute(clc, (char *)(multiplier->dp),
1432                                    (char *)(multiplicand->dp),
1433                                    (char *)((exp == NULL) ? NULL: exp->dp),
1434                                    (char *)(mod->dp),
1435                                    (int *)(result_tmp_ptr->dp),
1436                                    (length*sizeof(mp_digit)));
1437    MAX3266X_MSG("MAA Finished Computation");
1438    if (wc_MXC_error(&ret) != 0) {
1439        MAX3266X_MSG("HW Computation Error");
1440        wolfSSL_HwPkMutexUnLock();
1441        return ret;
1442    }
1443
1444    ret = wc_MXC_MAA_Shutdown();
1445    if (ret != 0) {
1446        MAX3266X_MSG("HW Shutdown Failure");
1447        /* Shutdown will always call wolfSSL_HwPkMutexUnLock(); */
1448        /* before returning */
1449        return ret;
1450    }
1451
1452    /* Copy tmp result if needed */
1453    if ((multiplier == result) || (multiplicand == result) || (exp == result) ||
1454            (mod == result)) {
1455        mp_copy(result_tmp_ptr, result);
1456        ForceZero(result_tmp_ptr, sizeof(mp_int)); /* force zero */
1457    }
1458
1459    result->used = wc_MXC_MAA_adjustUsed(result->dp, length);
1460    return ret;
1461}
1462
1463
1464
1465int wc_MXC_MAA_expmod(mp_int* base, mp_int* exp, mp_int* mod,
1466                            mp_int* result)
1467{
1468    mp_int multiplicand;
1469    if (base == NULL || exp == NULL || mod == NULL || result == NULL) {
1470        return BAD_FUNC_ARG;
1471    }
1472    XMEMSET(&multiplicand, 0, sizeof(mp_int));
1473    multiplicand.dp[0] = 0x01;
1474    multiplicand.used = mod->used;
1475    MAX3266X_MSG("Preparing exptmod MAA HW Call");
1476    return wc_MXC_MAA_math(base, &multiplicand, exp, mod, result,
1477                            MXC_TPU_MAA_EXP);
1478}
1479
1480int wc_MXC_MAA_sqrmod(mp_int* multiplier, mp_int* mod, mp_int* result)
1481{
1482    mp_int multiplicand;
1483    if (multiplier == NULL || mod == NULL || result == NULL) {
1484        return BAD_FUNC_ARG;
1485    }
1486    XMEMSET(&multiplicand, 0, sizeof(mp_int));
1487    multiplicand.dp[0] = 0x01;
1488    multiplicand.used = mod->used;
1489    MAX3266X_MSG("Preparing sqrmod MAA HW Call");
1490    return wc_MXC_MAA_math(multiplier, &multiplicand, NULL, mod, result,
1491                            MXC_TPU_MAA_SQ);
1492}
1493
1494int wc_MXC_MAA_mulmod(mp_int* multiplier, mp_int* multiplicand, mp_int* mod,
1495                            mp_int* result)
1496{
1497    if (multiplier == NULL || multiplicand == NULL || mod == NULL ||
1498            result == NULL) {
1499        return BAD_FUNC_ARG;
1500    }
1501    MAX3266X_MSG("Preparing mulmod MAA HW Call");
1502    return wc_MXC_MAA_math(multiplier, multiplicand, NULL, mod, result,
1503                            MXC_TPU_MAA_MUL);
1504}
1505
1506int wc_MXC_MAA_sqrmulmod(mp_int* multiplier, mp_int* multiplicand,
1507                            mp_int* exp, mp_int* mod, mp_int* result)
1508{
1509    if (multiplier == NULL || multiplicand == NULL || exp == NULL ||
1510            mod == NULL || result == NULL) {
1511        return BAD_FUNC_ARG;
1512    }
1513    MAX3266X_MSG("Preparing sqrmulmod MAA HW Call");
1514    return wc_MXC_MAA_math(multiplier, multiplicand, NULL, mod, result,
1515                            MXC_TPU_MAA_SQMUL);
1516}
1517
1518int wc_MXC_MAA_addmod(mp_int* multiplier, mp_int* multiplicand, mp_int* mod,
1519                            mp_int* result)
1520{
1521    if (multiplier == NULL || multiplicand == NULL || mod == NULL ||
1522            result == NULL) {
1523        return BAD_FUNC_ARG;
1524    }
1525    MAX3266X_MSG("Preparing addmod MAA HW Call");
1526    return wc_MXC_MAA_math(multiplier, multiplicand, NULL, mod, result,
1527                            MXC_TPU_MAA_ADD);
1528}
1529
1530int wc_MXC_MAA_submod(mp_int* multiplier, mp_int* multiplicand, mp_int* mod,
1531                            mp_int* result)
1532{
1533    if (multiplier == NULL || multiplicand == NULL || mod == NULL ||
1534            result == NULL) {
1535        return BAD_FUNC_ARG;
1536    }
1537    MAX3266X_MSG("Preparing submod MAA HW Call");
1538    if ((mod->used < multiplier->used) || (mod->used < multiplicand->used)) {
1539            MAX3266X_MSG("HW Limitation: Defaulting back to software");
1540            return mxc_submod(multiplier, multiplicand, mod, result);
1541    }
1542    else {
1543        return wc_MXC_MAA_math(multiplier, multiplicand, NULL, mod, result,
1544                             MXC_TPU_MAA_SUB);
1545    }
1546}
1547
1548/* General Function to call hardware control */
1549int hw_mulmod(mp_int* multiplier, mp_int* multiplicand, mp_int* mod,
1550                    mp_int* result)
1551{
1552    if (multiplier == NULL || multiplicand == NULL || mod == NULL ||
1553            result == NULL) {
1554        return MP_VAL;
1555    }
1556    if ((multiplier->used == 0) || (multiplicand->used == 0)) {
1557        mp_zero(result);
1558        return 0;
1559    }
1560    else {
1561        if (wc_MXC_MAA_Fallback(3, multiplier->used, mod->used,
1562                                multiplicand->used) != 0) {
1563                return mxc_mulmod(multiplier, multiplicand, mod, result);
1564        }
1565        else {
1566            return wc_MXC_MAA_mulmod(multiplier, multiplicand, mod, result);
1567        }
1568    }
1569}
1570
1571int hw_addmod(mp_int* a, mp_int* b, mp_int* mod, mp_int* result)
1572{
1573    int err = MP_OKAY;
1574    /* Validate parameters. */
1575    if ((a == NULL) || (b == NULL) || (mod == NULL) || (result == NULL)) {
1576        err = MP_VAL;
1577    }
1578    if (err == MP_OKAY) {
1579        if (wc_MXC_MAA_Fallback(3, a->used, b->used, mod->used) != 0) {
1580            err = mxc_addmod(a, b, mod, result);
1581        }
1582        else {
1583            err = wc_MXC_MAA_addmod(a, b, mod, result);
1584        }
1585    }
1586    return err;
1587}
1588
1589
1590int hw_submod(mp_int* a, mp_int* b, mp_int* mod, mp_int* result)
1591{
1592    int err = MP_OKAY;
1593    /* Validate parameters. */
1594    if ((a == NULL) || (b == NULL) || (mod == NULL) || (result == NULL)) {
1595        err = MP_VAL;
1596    }
1597    if (err == MP_OKAY) {
1598        if (wc_MXC_MAA_Fallback(3, a->used, b->used, mod->used) != 0) {
1599            err = mxc_submod(a, b, mod, result);
1600        }
1601        else{
1602            err = wc_MXC_MAA_submod(a, b, mod, result);
1603        }
1604    }
1605    return err;
1606}
1607
1608int hw_exptmod(mp_int* base, mp_int* exp, mp_int* mod, mp_int* result)
1609{
1610    int err = MP_OKAY;
1611    /* Validate parameters. */
1612    if ((base == NULL) || (exp == NULL) || (mod == NULL) || (result == NULL)) {
1613        err = MP_VAL;
1614    }
1615    if (err == MP_OKAY) {
1616        if ((mod->used < exp->used) || (mod->used < base->used)) {
1617            err = mxc_exptmod(base, exp, mod, result);
1618        }
1619        else if (wc_MXC_MAA_Fallback(3, base->used, exp->used, mod->used)
1620                    != 0) {
1621            return mxc_exptmod(base, exp, mod, result);
1622        }
1623        else{
1624            err = wc_MXC_MAA_expmod(base, exp, mod, result);
1625        }
1626    }
1627    return err;
1628}
1629
1630
1631/* No mod function available with hardware, however perform a submod    */
1632/* (a - 0) mod m will essentially perform the same operation as a mod m */
1633int hw_mod(mp_int* a, mp_int* mod, mp_int* result)
1634{
1635    mp_int b;
1636    if (a == NULL || mod == NULL || result == NULL) {
1637        return MP_VAL;
1638    }
1639    if (wc_MXC_MAA_Fallback(2, a->used, mod->used) != 0) {
1640        return mxc_mod(a, mod, result);
1641    }
1642    XMEMSET(&b, 0, sizeof(mp_int));
1643    b.used = mod->used; /* assume mod is determining size */
1644    return hw_submod(a, &b, mod, result);
1645}
1646
1647int hw_sqrmod(mp_int* base, mp_int* mod, mp_int* result)
1648{
1649    if (base == NULL || mod == NULL || result == NULL) {
1650        return MP_VAL;
1651    }
1652    if (base->used == 0) {
1653        mp_zero(result);
1654        return 0;
1655    }
1656    return wc_MXC_MAA_sqrmod(base, mod, result);
1657}
1658
1659#endif /* MAX3266X_MATH */
1660
1661#if defined(MAX3266X_RTC)
1662/* Initialize the RTC */
1663int wc_MXC_RTC_Init(void)
1664{
1665    /* RTC Init for benchmark */
1666    if (MXC_RTC_Init(0, 0) != E_NO_ERROR) {
1667        return WC_HW_E;
1668    }
1669    /* Disable the Interrupt */
1670    if (MXC_RTC_DisableInt(MXC_RTC_INT_EN_LONG) == E_BUSY) {
1671        return WC_HW_E;
1672    }
1673    /* Start Clock for RTC */
1674    if (MXC_RTC_SquareWaveStart(MXC_RTC_F_512HZ) == E_BUSY) {
1675        return E_BUSY;
1676    }
1677    /* Begin RTC count */
1678    if (MXC_RTC_Start() != E_NO_ERROR) {
1679        return WC_HW_E;
1680    }
1681    return 0;
1682}
1683
1684/* Reset the RTC */
1685int wc_MXC_RTC_Reset(void)
1686{
1687    /* Stops Counts */
1688    if (MXC_RTC_Stop() != E_NO_ERROR) {
1689        return WC_HW_E;
1690    }
1691    /* Restart RTC via Init */
1692    if (wc_MXC_RTC_Init() != E_NO_ERROR) {
1693        return WC_HW_E;
1694    }
1695    return 0;
1696}
1697
1698/* Function to handle RTC read retries */
1699void wc_MXC_RTC_GetRTCValue(int32_t (*rtcGetFunction)(uint32_t*),
1700                                uint32_t* outValue, int32_t* err)
1701{
1702    *err = rtcGetFunction(outValue);  /* Initial attempt to get the value */
1703    while (*err != E_NO_ERROR) {
1704        *err = rtcGetFunction(outValue);  /* Retry if the error persists */
1705    }
1706}
1707
1708/* Function to provide the current time as a double */
1709/* Returns seconds and millisecond */
1710double wc_MXC_RTC_Time(void)
1711{
1712    int32_t err;
1713    uint32_t rtc_seconds, rtc_subseconds;
1714
1715    /* Retrieve sub-seconds from RTC */
1716    wc_MXC_RTC_GetRTCValue((int32_t (*)(uint32_t*))MXC_RTC_GetSubSeconds,
1717                                    &rtc_subseconds, &err);
1718    if (err != E_NO_ERROR) {
1719        return (double)err;
1720    }
1721    /* Retrieve seconds from RTC */
1722    wc_MXC_RTC_GetRTCValue((int32_t (*)(uint32_t*))MXC_RTC_GetSeconds,
1723                                &rtc_seconds, &err);
1724    if (err != E_NO_ERROR) {
1725        return (double)err;
1726    }
1727    /* Per the device documentation, subsecond register holds up to 1 second */
1728    /* subsecond register is size 2^12, so divide by 4096 to get milliseconds */
1729    return ((double)rtc_seconds + ((double)rtc_subseconds / 4096));
1730}
1731
1732#endif /* MAX3266X_RTC */
1733
1734#endif /* WOLFSSL_MAX32665 || WOLFSSL_MAX32666 */