luna - wolfssl/wolfcrypt/src/port/caam/caam

   1/* caam_driver.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#if (defined(__INTEGRITY) || defined(INTEGRITY)) || \
  27    (defined(__QNX__) || defined(__QNXNTO__))
  28
  29#if defined(__QNX__) || defined(__QNXNTO__)
  30    #include <sys/mman.h>
  31    #ifdef __aarch64__
  32        #include <aarch64/inout.h>
  33    #else
  34        #include <hw/inout.h>
  35    #endif
  36    #include <sys/iofunc.h>
  37    #include <sys/neutrino.h>
  38
  39    #include <wolfssl/wolfcrypt/port/caam/caam_qnx.h>
  40#endif
  41
  42#include <wolfssl/wolfcrypt/port/caam/caam_driver.h>
  43#include <wolfssl/wolfcrypt/port/caam/caam_error.h>
  44
  45#include <string.h> /* for memcpy / memset */
  46
  47struct JobRing {
  48    /* base address for job ring */
  49    CAAM_ADDRESS BaseAddr;
  50
  51    /* physical address */
  52    CAAM_ADDRESS JobIn;
  53    CAAM_ADDRESS JobOut;
  54    CAAM_ADDRESS Desc;
  55
  56    /* virtual address */
  57    void* VirtualIn;
  58    void* VirtualOut;
  59    void* VirtualDesc;
  60    Value   page;    /* page allocation for descriptor to use */
  61    CAAM_MUTEX jr_lock;
  62};
  63
  64struct CAAM_DEVICE {
  65#if defined(__INTEGRITY) || defined(INTEGRITY)
  66    struct IODeviceVectorStruct caamVector;
  67    struct IODescriptorStruct   IODescriptorArray[BUFFER_COUNT];
  68    struct DescStruct           DescArray[DESC_COUNT];
  69    volatile Value              InterruptStatus;
  70    CALL                        HandleInterruptCall;
  71#endif
  72    struct JobRing ring;
  73    CAAM_ADDRESS   baseAddr;     /* base address for CAAM */
  74    unsigned short vrs;          /* era version number of CAAM */
  75};
  76
  77#define DRIVER_NAME "wolfSSL_CAAM_Driver"
  78
  79static struct CAAM_DEVICE caam;
  80
  81/* function declarations */
  82Error caamAddJob(DESCSTRUCT* desc);
  83Error caamDoJob(DESCSTRUCT* desc);
  84
  85
  86
  87/******************************************************************************
  88  Internal CAAM Job Ring and partition functions
  89  ****************************************************************************/
  90
  91#ifdef CAAM_DEBUG_MODE
  92/* runs a descriptor in debug mode */
  93static Error caamDebugDesc(struct DescStruct* desc)
  94{
  95    int z;
  96    int sz;
  97    unsigned int flag = 0x20000000;
  98
  99    /* clear and set desc size */
 100    sz = desc->desc[0] & 0x0000007F;
 101    CAAM_WRITE(CAAM_DECORR, 1); /* ask for DECO permissions */
 102    printf("CAAM_DECORR = 0x%08X\n", CAAM_READ(CAAM_DECORR));
 103    printf("STATUS : 0x%08X\n", CAAM_READ(CAAM_DOOPSTA_MS));
 104    printf("CAAM STATUS : 0x%08X\n", CAAM_READ(0x0FD4));
 105    printf("DECO DRG (bit 32 is valid -- running) : 0x%08X\n", CAAM_READ(0x8E04));
 106
 107    printf("Descriptor input :\n");
 108    /* write descriptor into descriptor buffer */
 109    for (z = 0; z < sz; z = z + 1) {
 110        CAAM_WRITE(CAAM_DODESB + (z*4), desc->desc[z]);
 111        printf("\t0x%08X\n", desc->desc[z]);
 112    }
 113    printf("\n");
 114
 115    printf("command size = %d\n", sz);
 116    if (sz > 4) {
 117        flag |= 0x10000000;
 118    }
 119
 120    CAAM_WRITE(CAAM_DODAR+4, desc->caam->ring.Desc);
 121    /* set WHL bit since we loaded the entire descriptor */
 122    CAAM_WRITE(CAAM_DOJQCR_MS, flag);
 123
 124    printf("CAAM STATUS : 0x%08X\n", CAAM_READ(0x0FD4));
 125    printf("DECO DRG (bit 32 is valid -- running) : 0x%08X\n", CAAM_READ(0x8E04));
 126
 127    /* DECO buffer */
 128    printf("DECO BUFFER [0x%08X]:\n", CAAM_READ(CAAM_DODAR+4));
 129    printf("\tSTATUS : 0x%08X\n", CAAM_READ(CAAM_DOOPSTA_MS));
 130    printf("\tJRSTAR_JR0 : 0x%08X\n", CAAM_READ(0x1044));
 131    for (z = 0; z < sz; z = z + 1) {
 132        printf("\t0x%08X\n", CAAM_READ(CAAM_DODESB + (z*4)));
 133    }
 134
 135
 136    /* D0JQCR_LS */
 137    printf("Next command to be executed = 0x%08X\n", CAAM_READ(0x8804));
 138    printf("Desc          = 0x%08X\n", desc->caam->ring.Desc);
 139
 140
 141    /* DECO buffer */
 142    printf("DECO BUFFER [0x%08X]:\n", CAAM_READ(CAAM_DODAR+4));
 143    printf("\tSTATUS : 0x%08X\n", CAAM_READ(CAAM_DOOPSTA_MS));
 144    printf("\tJRSTAR_JR0 : 0x%08X\n", CAAM_READ(0x1044));
 145    for (z = 0; z < sz; z = z + 1) {
 146        printf("\t0x%08X\n", CAAM_READ(CAAM_DODESB + (z*4)));
 147    }
 148
 149    printf("Next command to be executed = 0x%08X\n", CAAM_READ(0x8804));
 150    printf("CAAM STATUS : 0x%08X\n", CAAM_READ(0x0FD4));
 151    while ((CAAM_READ(0x8E04) & 0x80000000U) != 0U) {
 152        printf("DECO DRG (bit 32 is valid -- running) : 0x%08X\n",
 153                CAAM_READ(0x8E04));
 154        sleep(1);
 155    }
 156    CAAM_WRITE(CAAM_DECORR, 0); /* free DECO */
 157    printf("done with debug job\n");
 158    return Success;
 159}
 160#endif /* CAAM_DEBUG_MODE */
 161
 162
 163#if defined(WOLFSSL_CAAM_DEBUG) || defined(WOLFSSL_CAAM_PRINT)
 164static void printSecureMemoryInfo()
 165{
 166    unsigned int SMVID_MS, SMVID_LS;
 167
 168    printf("SMSTA = 0x%08X\n", CAAM_READ(caam.ring.BaseAddr + 0x0FB4));
 169    printf("SMPO  = 0x%08X\n", CAAM_READ(caam.ring.BaseAddr + CAAM_SM_SMPO));
 170    SMVID_MS = CAAM_READ(caam.ring.BaseAddr + CAAM_SM_SMVID_MS);
 171    SMVID_LS = CAAM_READ(caam.ring.BaseAddr + CAAM_SM_SMVID_LS);
 172    printf("\tNumber Partitions : %d\n", ((SMVID_MS >> 12) & 0xFU));
 173    printf("\tNumber Pages : %d\n", (SMVID_MS & 0x3FFU));
 174    printf("\tPage Size : 2^%d\n", ((SMVID_LS >> 16) & 0x7U));
 175}
 176#endif
 177
 178/* flush job ring and reset */
 179static Error caamReset(void)
 180{
 181    int t = 100000; /* time out counter for flushing job ring */
 182
 183    /* make sure interrupts are masked in JRCFGR0_LS register */
 184    CAAM_WRITE(caam.ring.BaseAddr + JRCFGR_JR,
 185        CAAM_READ(caam.ring.BaseAddr + JRCFGR_JR) | 1);
 186
 187    /* flush and reset job rings using JRCR0 register */
 188    CAAM_WRITE(caam.ring.BaseAddr + JRCR_JR, 1);
 189
 190    /* check register JRINTR for if halt is in progress */
 191    while (t > 0 && ((CAAM_READ(caam.ring.BaseAddr + JRINTR_JR) & 0x4)
 192        == 0x4)) {
 193        t = t - 1;
 194    }
 195    if (t == 0) {
 196        /*unrecoverable failure, the job ring is locked, up hard reset needed*/
 197        return -1;
 198    }
 199
 200    /* now that flush has been done restart the job ring */
 201    t = 100000;
 202    CAAM_WRITE(caam.ring.BaseAddr + JRCR_JR, 1);
 203    while (t > 0 && ((CAAM_READ(caam.ring.BaseAddr + JRCR_JR) & 1) == 1)) {
 204        t = t - 1;
 205    }
 206    if (t == 0) {
 207        /*unrecoverable failure, reset bit did not return to 0 */
 208        return -1;
 209    }
 210
 211    if (caam.vrs < 9) {
 212        /* reset most registers and state machines in CAAM using MCFGR register
 213           also reset DMA */
 214        CAAM_WRITE(caam.baseAddr + CAAM_RSTA, 0x90000000);
 215
 216        /* DDR */
 217        CAAM_WRITE(caam.baseAddr + CAAM_DRR, 1);
 218    }
 219
 220    return Success;
 221}
 222
 223
 224/* free the page and dealloc */
 225static Error caamFreePage(unsigned int page)
 226{
 227    /* owns the page can dealloc it */
 228    CAAM_WRITE(caam.ring.BaseAddr + CAAM_SM_CMD, (page << 16U) | 0x2U);
 229    while ((CAAM_READ(caam.ring.BaseAddr + CAAM_SM_STATUS) & 0x00004000) > 0 &&
 230        (CAAM_READ(caam.ring.BaseAddr + CAAM_SM_STATUS) & 0x00003000)  == 0) {
 231        CAAM_CPU_CHILL();
 232    }
 233    if ((CAAM_READ(caam.ring.BaseAddr + CAAM_SM_STATUS) & 0x00003000)  > 0) {
 234        /* error while deallocating page */
 235        WOLFSSL_MSG("error while deallocating page");
 236        return MemoryMapMayNotBeEmpty; /* PSP set on page or is unavailable */
 237    }
 238    WOLFSSL_MSG("free'd page");
 239    return Success;
 240}
 241
 242/* free the partition and dealloc */
 243Error caamFreePart(unsigned int part)
 244{
 245    unsigned int status;
 246
 247    #if defined(WOLFSSL_CAAM_DEBUG) || defined(WOLFSSL_CAAM_PRINT)
 248    printf("freeing partition %d\n", part);
 249    #endif
 250    CAAM_WRITE(caam.ring.BaseAddr + CAAM_SM_CMD, (part << 8U) | 0x3U);
 251
 252    status = CAAM_READ(caam.ring.BaseAddr + CAAM_SM_STATUS);
 253    while (((status & 0x00004000U) > 0U) && ((status & 0x00003000U) == 0U)) {
 254        CAAM_CPU_CHILL();
 255        status = CAAM_READ(caam.ring.BaseAddr + CAAM_SM_STATUS);
 256    }
 257
 258    if (((status & 0x00003000U) > 0U) || ((status & 0x0000C000U) > 0U)) {
 259        /* error while deallocating page */
 260        WOLFSSL_MSG("error while deallocating partition");
 261        return MemoryMapMayNotBeEmpty; /* PSP set on page or is unavailable */
 262    }
 263    WOLFSSL_MSG("free'd partition");
 264    return Success;
 265}
 266
 267
 268/* find all partitions we own and free them */
 269static Error caamFreeAllPart()
 270{
 271    unsigned int SMPO;
 272    unsigned int i;
 273
 274    WOLFSSL_MSG("Free all partitions");
 275    SMPO = CAAM_READ(caam.ring.BaseAddr + CAAM_SM_SMPO);
 276    for (i = 0; i < 15U; i = i + 1U) {
 277        if ((SMPO & (0x3U << (i * 2U))) == (0x3U << (i * 2U))) {
 278            caamFreePart(i);
 279        }
 280    }
 281
 282    return 0;
 283}
 284
 285
 286/* search through the partitions to find an unused one
 287 * returns negative value on failure, on success returns 0 or greater
 288 */
 289int caamFindUnusedPartition()
 290{
 291    unsigned int SMPO;
 292    unsigned int i;
 293    int ret = -1;
 294
 295    SMPO = CAAM_READ(caam.ring.BaseAddr + CAAM_SM_SMPO);
 296    for (i = 0; i < 15U; i = i + 1) {
 297        if ((SMPO & (0x3U << (i * 2U))) == 0U) {
 298            ret = (int)i;
 299            break;
 300        }
 301    }
 302
 303    return ret;
 304}
 305
 306
 307/* flag contains how the partition is set i.e CSP flag and read/write access
 308 *      it also contains if locked
 309 */
 310static Error caamCreatePartition(unsigned int* page, unsigned int par,
 311        unsigned int flag)
 312{
 313    int testPage;
 314    unsigned int status;
 315
 316    /* check ownership of partition */
 317    status = CAAM_READ(caam.ring.BaseAddr + CAAM_SM_SMPO);
 318    if ((status & (0x3U << (par * 2))) > 0) {
 319        if ((status & (0x3U << (par * 2))) == (0x3U << (par * 2))) {
 320            WOLFSSL_MSG("we own this partition!");
 321        }
 322        else {
 323            return MemoryMapMayNotBeEmpty;
 324        }
 325    }
 326    CAAM_WRITE(caam.ring.BaseAddr + CAAM_SMAPR + (par * 16), flag);
 327
 328    /* dealloc page if we own it */
 329    for (testPage = 0; testPage < 16; testPage++) {
 330        CAAM_WRITE(caam.ring.BaseAddr + CAAM_SM_CMD, (testPage << 16) | 0x5);
 331        while ((CAAM_READ(caam.ring.BaseAddr + CAAM_SM_STATUS) & 0x00004000) > 0
 332            && (CAAM_READ(caam.ring.BaseAddr + CAAM_SM_STATUS) & 0x00003000)
 333            == 0) {
 334            CAAM_CPU_CHILL();
 335        }
 336        if ((CAAM_READ(caam.ring.BaseAddr + CAAM_SM_STATUS) & 0x000000C0) ==
 337            0xC0) {
 338            if (caamFreePage(testPage) != Success) {
 339                continue;
 340            }
 341        }
 342        else if ((CAAM_READ(caam.ring.BaseAddr + CAAM_SM_STATUS) & 0x000000C0)
 343            == 0x00) {
 344            WOLFSSL_MSG("testPage available and un-owned");
 345        }
 346        else {
 347            WOLFSSL_MSG("we don't own the testPage...");
 348            continue;
 349        }
 350
 351        CAAM_WRITE(caam.ring.BaseAddr + CAAM_SM_CMD, (testPage << 16) |
 352            (par << 8) | 0x1);
 353        /* wait for alloc cmd to complete */
 354        while ((CAAM_READ(caam.ring.BaseAddr + CAAM_SM_STATUS) & 0x00004000) > 0 &&
 355           (CAAM_READ(caam.ring.BaseAddr + CAAM_SM_STATUS) & 0x00003000)  == 0) {
 356            CAAM_CPU_CHILL();
 357        }
 358        break;
 359    }
 360    if (testPage == 16)
 361        return -1;
 362    *page=testPage;
 363
 364    return Success;
 365}
 366
 367
 368/* return a partitions physical address on success, returns 0 on fail */
 369CAAM_ADDRESS caamGetPartition(unsigned int part, int partSz, unsigned int flag)
 370{
 371    int err;
 372
 373    (void)flag; /* flag is for future changes to flag passed when creating */
 374
 375    /* create and claim the partition */
 376    err = caamCreatePartition(&part, part, CAAM_SM_CSP | CAAM_SM_SMAP_LOCK |
 377                CAAM_SM_CSP | CAAM_SM_ALL_RW);
 378    if (err != Success) {
 379        WOLFSSL_MSG("Error creating partitions for secure ecc key");
 380        return 0;
 381    }
 382
 383    return (CAAM_ADDRESS)(CAAM_PAGE + (part << 12));
 384}
 385
 386
 387/* Gets the status of a job. Returns CAAM_WAITING if no output jobs ready to be
 388 * read.
 389 * If no jobs are done then return CAAM_WAITING
 390 * If jobs are done but does not match desc then return NoActivityReady
 391 * Status holds the error values if any */
 392static Error caamGetJob(struct CAAM_DEVICE* dev, unsigned int* status)
 393{
 394    CAAM_ADDRESS baseAddr;
 395    unsigned int reg;
 396    if (status) {
 397        *status = 0;
 398    }
 399
 400    baseAddr = caam.ring.BaseAddr;
 401
 402#ifdef CAAM_DEBUG_MODE
 403    (void)dev;
 404    return Success;
 405#endif
 406
 407    /* Check number of done jobs in output list */
 408    reg = CAAM_READ(baseAddr + CAAM_ORJAR);
 409#if defined(WOLFSSL_CAAM_DEBUG) || defined(WOLFSSL_CAAM_PRINT)
 410    printf("number of jobs in output list = 0x%08X\n", reg);
 411#endif
 412    if ((reg & 0x000003FF) > 0) {
 413        unsigned int *pt;
 414
 415        if (CAAM_ADR_SYNC(caam.ring.VirtualOut, (2 * CAAM_JOBRING_SIZE *
 416                        sizeof(unsigned int))) != 0) {
 417            return -1;
 418        }
 419
 420        /* sanity check on job out */
 421        pt = (unsigned int*)caam.ring.VirtualOut;
 422        if (pt[0] != (unsigned int)caam.ring.Desc) {
 423        #if defined(WOLFSSL_CAAM_DEBUG) || defined(WOLFSSL_CAAM_PRINT)
 424            printf("Job found %08X does not match expected job %08X\n",
 425                    pt[0], (unsigned int)caam.ring.Desc);
 426        #endif
 427            return -1;
 428        }
 429        *status = pt[1];
 430
 431        /* increment jobs removed */
 432    #if defined(WOLFSSL_CAAM_DEBUG) || defined(WOLFSSL_CAAM_PRINT)
 433        printf("\tjob 0x%08X done - result 0x%08X\n", pt[0], pt[1]);
 434        printf("removing job from list\n");
 435        fflush(stdout);
 436    #endif
 437        CAAM_WRITE(baseAddr + CAAM_ORJRR, 1);
 438    }
 439    else {
 440        /* check if the CAAM is idle and not processing any descriptors */
 441        if ((CAAM_READ(baseAddr + 0x0FD4) & 0x00000002) == 2 /* idle */
 442        && (CAAM_READ(baseAddr + 0x0FD4) & 0x00000001) == 0) {
 443            WOLFSSL_MSG("caam is idle.....");
 444            return NoActivityReady;
 445        }
 446        return CAAM_WAITING;
 447    }
 448    (void)dev;
 449
 450    CAAM_WRITE(baseAddr + JRCFGR_JR, 0);
 451    if (*status == 0) {
 452        return Success;
 453    }
 454    return Failure;
 455}
 456
 457
 458/* instantiate RNG and create JDKEK, TDKEK, and TDSK key */
 459#define WC_RNG_START_SIZE 6
 460static unsigned int wc_rng_start[WC_RNG_START_SIZE] = {
 461    CAAM_HEAD | 0x00000006,
 462    CAAM_OP | CAAM_CLASS1 | CAAM_RNG | 0x00000004, /* Instantiate RNG handle 0
 463                                                      with TRNG */
 464    CAAM_JUMP | 0x02000001,  /* wait for Class1 RNG and jump to next cmd */
 465    CAAM_LOAD | 0x00880004,  /* Load to clear written register */
 466    0x00000001, /* reset done interrupt */
 467    CAAM_OP | CAAM_CLASS1 | CAAM_RNG | 0x00001000   /* Generate secure keys */
 468};
 469
 470
 471/* Initialize CAAM RNG
 472 * returns 0 on success */
 473int caamInitRng(struct CAAM_DEVICE* dev);
 474int caamInitRng(struct CAAM_DEVICE* dev)
 475{
 476    DESCSTRUCT desc;
 477    unsigned int reg, entropy_delay;
 478    int ret = 0, i;
 479
 480    /* set up the job description for RNG initialization */
 481    memset(&desc, 0, sizeof(DESCSTRUCT));
 482    desc.desc[desc.idx++] = CAAM_HEAD; /* later will put size to header*/
 483    for (i = 1; i < WC_RNG_START_SIZE; i++) {
 484        desc.desc[desc.idx++] = wc_rng_start[i];
 485    }
 486    desc.caam = dev;
 487
 488    /* Attempt to start the RNG, first trying the fastest entropy delay value
 489     * and increasing it after each failed attempt until either a success is hit
 490     * or the max delay value is.
 491     */
 492    for (entropy_delay = CAAM_ENT_DLY; entropy_delay <= CAAM_ENT_DLY_MAX;
 493            entropy_delay = entropy_delay + CAAM_ENT_DLY_INCREMENT) {
 494
 495        /* Set up use of the TRNG for seeding wolfSSL HASH-DRBG */
 496        /* check out the status and see if already setup */
 497        CAAM_WRITE(caam.baseAddr + CAAM_RTMCTL, CAAM_PRGM);
 498        CAAM_WRITE(caam.baseAddr + CAAM_RTMCTL,
 499                CAAM_READ(caam.baseAddr + CAAM_RTMCTL) | CAAM_RTMCTL_RESET);
 500
 501        /* Set up reading from TRNG */
 502        CAAM_WRITE(caam.baseAddr + CAAM_RTMCTL,
 503                CAAM_READ(caam.baseAddr + CAAM_RTMCTL) | CAAM_TRNG);
 504
 505        /* Set up delay for TRNG
 506         * Shift left with RTSDCTL because 0-15 is for sample number
 507         * Also setting the max and min frequencies */
 508        CAAM_WRITE(caam.baseAddr + CAAM_RTSDCTL,
 509                (entropy_delay << 16) | CAAM_ENT_SAMPLE);
 510        CAAM_WRITE(caam.baseAddr + CAAM_RTFRQMIN,
 511                entropy_delay >> CAAM_ENT_MINSHIFT);
 512        CAAM_WRITE(caam.baseAddr + CAAM_RTFRQMAX,
 513                entropy_delay << CAAM_ENT_MAXSHIFT);
 514
 515    #ifdef WOLFSSL_CAAM_PRINT
 516        printf("Attempt with entropy delay set to %d\n", entropy_delay);
 517        printf("Min delay of %d and max of %d\n",
 518                entropy_delay >> CAAM_ENT_MINSHIFT,
 519                entropy_delay << CAAM_ENT_MAXSHIFT);
 520    #endif
 521
 522        /* Set back to run mode and clear RTMCL error bit */
 523        reg = CAAM_READ(caam.baseAddr + CAAM_RTMCTL) & (~CAAM_PRGM);
 524        CAAM_WRITE(caam.baseAddr + CAAM_RTMCTL, reg);
 525        reg = CAAM_READ(caam.baseAddr + CAAM_RTMCTL);
 526        reg |= CAAM_CTLERR;
 527        CAAM_WRITE(caam.baseAddr + CAAM_RTMCTL, reg);
 528
 529        /* check out the status and see if already setup */
 530        reg = CAAM_READ(caam.baseAddr + CAAM_RDSTA);
 531        if (((reg >> 16) & 0xF) > 0) {
 532            WOLFSSL_MSG("RNG is in error state, resetting");
 533            caamReset();
 534        }
 535
 536        if (reg & (1U << 30)) {
 537            WOLFSSL_MSG("JKDKEK rng was setup using a non deterministic key");
 538            return 0;
 539        }
 540
 541        do {
 542            ret = caamDoJob(&desc);
 543        } while (ret == CAAM_WAITING);
 544
 545        /* if this entropy delay frequency succeeded then break out, otherwise
 546         * try again with increasing the delay value */
 547        if (ret == Success) {
 548            WOLFSSL_MSG("Init RNG success");
 549            break;
 550        }
 551        WOLFSSL_MSG("Increasing entropy delay");
 552    }
 553
 554    if (ret == Success)
 555        return 0;
 556    return -1;
 557}
 558
 559
 560/* Take in a descriptor and add it to the job list */
 561Error caamAddJob(DESCSTRUCT* desc)
 562{
 563    CAAM_ADDRESS baseAddr;
 564
 565    /* clear and set desc size */
 566    desc->desc[0] &= 0xFFFFFF80;
 567    desc->desc[0] += desc->idx + (desc->startIdx << 16);
 568
 569    CAAM_LOCK_MUTEX(&caam.ring.jr_lock);
 570    baseAddr = caam.ring.BaseAddr;
 571
 572    /* check input slot is available and then add */
 573    if (CAAM_READ(baseAddr + CAAM_IRSAR_JR) > 0) {
 574        int i;
 575        unsigned int *pt;
 576
 577        pt = (unsigned int*)caam.ring.VirtualDesc;
 578    #if defined(WOLFSSL_CAAM_PRINT)
 579        printf("Number of input ring slots available is %d\n",
 580            CAAM_READ(baseAddr + CAAM_IRSAR_JR));
 581        printf("Doing Job :\n");
 582    #endif
 583        for (i = 0; i < desc->idx; i = i + 1) {
 584            pt[i] = desc->desc[i];
 585    #if defined(WOLFSSL_CAAM_PRINT)
 586            printf("\tCMD %02d [%p] = 0x%08X\n", i+1, pt + i,
 587                  desc->desc[i]);
 588    #endif
 589        }
 590
 591        pt    = (unsigned int*)caam.ring.VirtualIn;
 592        pt[0] = (unsigned int)caam.ring.Desc;
 593
 594        /* Sync both the virtual in and the descriptor */
 595        if (CAAM_ADR_SYNC(caam.ring.VirtualIn,
 596                    (CAAM_JOBRING_SIZE * sizeof(unsigned int)) +
 597                    (desc->idx * sizeof(unsigned int))) != 0) {
 598            CAAM_UNLOCK_MUTEX(&caam.ring.jr_lock);
 599            return -1;
 600        }
 601
 602    #ifdef CAAM_DEBUG_MODE
 603        caamDebugDesc(desc);
 604    #else
 605        #if defined(WOLFSSL_CAAM_DEBUG) || defined(WOLFSSL_CAAM_PRINT)
 606        printf("started job 0x%08X done\n", (unsigned int)caam.ring.Desc);
 607        #endif
 608        CAAM_WRITE(baseAddr + CAAM_IRJAR0, 0x00000001);
 609    #endif
 610    }
 611    else {
 612        CAAM_UNLOCK_MUTEX(&caam.ring.jr_lock);
 613        return CAAM_WAITING;
 614    }
 615    CAAM_UNLOCK_MUTEX(&caam.ring.jr_lock);
 616    return Success;
 617}
 618
 619
 620/* Synchronous job completion, add it to job queue and wait till finished */
 621Error caamDoJob(DESCSTRUCT* desc)
 622{
 623    Error ret;
 624    unsigned int status;
 625
 626    ret = caamAddJob(desc);
 627    if (ret != Success) {
 628        return ret;
 629    }
 630
 631    do {
 632        ret = caamGetJob(desc->caam, &status);
 633        CAAM_CPU_CHILL();
 634    } while (ret == CAAM_WAITING);
 635
 636    #if defined(WOLFSSL_CAAM_DEBUG) || defined(WOLFSSL_CAAM_PRINT)
 637    printf("job status = 0x%08X, ret = %d\n", status, ret);
 638    #endif
 639
 640    /* try to reset after error */
 641    if (status != 0 || ret != Success) {
 642        /* consider any job ring errors as fatal, and try reset */
 643        if (caamParseJRError(CAAM_READ(caam.ring.BaseAddr + JRINTR_JR)) != 0) {
 644            caamReset();
 645        }
 646        caamParseError(status);
 647        return ret;
 648    }
 649
 650    return Success;
 651}
 652
 653
 654/******************************************************************************
 655  CAAM Blob Operations
 656  ****************************************************************************/
 657
 658/* limit on size due to size of job ring being 64 unsigned int's */
 659int caamBlob(DESCSTRUCT* desc)
 660{
 661    void *vaddrOut, *vaddr, *keymod;
 662    Error err;
 663    unsigned int keyType = 0x00000C08; /* default red */
 664    unsigned int i = 0;
 665    int inputSz;
 666    int outputSz;
 667
 668    if (desc->idx + 3 > MAX_DESC_SZ) {
 669        return Failure;
 670    }
 671
 672    /* doing black blobs */
 673    if (desc->state) {
 674        WOLFSSL_MSG("making a black blob");
 675        keyType = 0x00000010;
 676    }
 677
 678    desc->desc[desc->idx++] = (CAAM_LOAD_CTX | CAAM_CLASS2 | keyType);
 679
 680    /* add key modifier */
 681    keymod = CAAM_ADR_MAP(desc->buf[i].data, desc->buf[i].dataSz, 1);
 682    desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(keymod, desc->buf[i].dataSz);
 683    i++;
 684
 685    inputSz = desc->buf[i].dataSz;
 686    if (desc->state && (desc->type == CAAM_BLOB_ENCAP)) {
 687        /* black keys with CCM have mac at the end */
 688        inputSz += BLACK_KEY_MAC_SZ;
 689    }
 690
 691    vaddr = CAAM_ADR_MAP(desc->buf[i].data, inputSz, 1);
 692
 693    /* add input */
 694    desc->desc[desc->idx++] = CAAM_SEQI + desc->buf[i].dataSz;
 695    desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr, inputSz);
 696    i++;
 697    desc->outputIdx = i;
 698
 699    outputSz = desc->buf[i].dataSz;
 700    if (desc->state && (desc->type == CAAM_BLOB_DECAP)) {
 701        /* black keys with CCM have mac at the end */
 702        outputSz += BLACK_KEY_MAC_SZ;
 703    }
 704    vaddrOut = CAAM_ADR_MAP(desc->buf[i].data, outputSz, 0);
 705
 706    /* add output */
 707    desc->desc[desc->idx++] = CAAM_SEQO + desc->buf[i].dataSz;
 708    desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddrOut, outputSz);
 709    if (desc->idx + 1 > MAX_DESC_SZ) {
 710        return Failure;
 711    }
 712    desc->desc[desc->idx] = CAAM_OP |  CAAM_OPID_BLOB | desc->type;
 713
 714    if (desc->state) {
 715        desc->desc[desc->idx] |= 0x104; /* EKT and Black_key (key is covered) */
 716    }
 717    desc->idx++;
 718    do {
 719        err = caamDoJob(desc);
 720    } while (err == CAAM_WAITING);
 721
 722    CAAM_ADR_UNMAP(keymod, desc->buf[0].data, desc->buf[0].dataSz, 0);
 723    CAAM_ADR_UNMAP(vaddr, desc->buf[1].data, inputSz, 0);
 724    CAAM_ADR_UNMAP(vaddrOut, desc->buf[2].data, outputSz, 1);
 725
 726    return err;
 727}
 728
 729
 730/******************************************************************************
 731  CAAM AES Operations
 732  ****************************************************************************/
 733
 734static void caamAddFIFOLPhy(DESCSTRUCT* desc, unsigned int in, int inSz,
 735    unsigned int flush)
 736{
 737    /* if size is larger than short type then use extended length option */
 738    if (inSz > 0xFFFF) {
 739        desc->desc[desc->idx++] = (CAAM_FIFO_L | flush | FIFOS_EXT |
 740                                   CAAM_CLASS1 | FIFOL_TYPE_MSG);
 741        desc->desc[desc->idx++] = in;
 742        desc->desc[desc->idx++] = inSz;
 743    }
 744    else {
 745        desc->desc[desc->idx++] = (CAAM_FIFO_L | flush |
 746                                   CAAM_CLASS1 | FIFOL_TYPE_MSG) + inSz;
 747        desc->desc[desc->idx++] = in;
 748    }
 749}
 750
 751
 752static void caamAddFIFOL(DESCSTRUCT* desc, void* in, int inSz,
 753    unsigned int flush)
 754{
 755    caamAddFIFOLPhy(desc, CAAM_ADR_TO_PHYSICAL(in, inSz), inSz, flush);
 756}
 757
 758
 759static void caamAddFIFOSPhy(DESCSTRUCT* desc, unsigned int out, int outSz)
 760{
 761    /* if size is larger than short type then use extended length option */
 762    if (outSz > 0xFFFF) {
 763        desc->desc[desc->idx++] = CAAM_FIFO_S | FIFOS_TYPE_MSG | FIFOS_EXT;
 764        desc->desc[desc->idx++] = out;
 765        desc->desc[desc->idx++] = outSz;
 766    }
 767    else {
 768        desc->desc[desc->idx++] = (CAAM_FIFO_S | FIFOS_TYPE_MSG) + outSz;
 769        desc->desc[desc->idx++] = out;
 770    }
 771}
 772
 773
 774static void caamAddFIFOS(DESCSTRUCT* desc, void* out, int outSz)
 775{
 776    caamAddFIFOSPhy(desc, CAAM_ADR_TO_PHYSICAL(out, outSz), outSz);
 777}
 778
 779
 780int caamAesCmac(DESCSTRUCT* desc, int sz, unsigned int args[4])
 781{
 782    Error err;
 783    unsigned int keySz;
 784    unsigned int macSz = 0;
 785    void *vaddr[4] = {0};
 786    unsigned int vidx = 0;
 787    unsigned int ctx;
 788    unsigned int isBlackKey;
 789    int i;
 790
 791    isBlackKey = args[2];
 792    keySz = args[1];
 793
 794    /* Get CTX physical address */
 795    vaddr[vidx] = CAAM_ADR_MAP(desc->buf[1].data, desc->buf[1].dataSz, 1);
 796    ctx = CAAM_ADR_TO_PHYSICAL(vaddr[vidx], desc->buf[1].dataSz);
 797    vidx++;
 798
 799    /* LOAD KEY */
 800    desc->desc[desc->idx] = (CAAM_KEY | CAAM_CLASS1 | CAAM_NWB) + keySz;
 801    if (isBlackKey) {
 802        desc->desc[desc->idx] |= CAAM_LOAD_BLACK_KEY;
 803        macSz = BLACK_KEY_MAC_SZ;
 804    }
 805    desc->idx++;
 806    vaddr[vidx] = CAAM_ADR_MAP(desc->buf[0].data, desc->buf[0].dataSz + macSz, 1);
 807    desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[vidx],
 808            desc->buf[0].dataSz + macSz);
 809    DEBUG_PRINT_ARRAY(vaddr[vidx], keySz, "AES CMAC Key");
 810    vidx++;
 811
 812    /* Load in CTX only when not initialization */
 813    if ((desc->state & CAAM_ALG_INIT) == 0) {
 814        int ofst = 0;
 815        desc->desc[desc->idx++] = (CAAM_LOAD_CTX | CAAM_CLASS1 | ofst) +
 816            desc->buf[1].dataSz;
 817        desc->desc[desc->idx++] = ctx;
 818        DEBUG_PRINT_ARRAY(vaddr[0], 32, "AES CMAC CTX");
 819    }
 820
 821    /* add protinfo to operation command */
 822    desc->desc[desc->idx++] = CAAM_OP | CAAM_CLASS1 | desc->type | desc->state;
 823
 824    /* add in all input buffers */
 825    for (i = 2; i < sz; i = i + 1) {
 826        desc->desc[desc->idx] = (CAAM_FIFO_L | CAAM_CLASS1 | FIFOL_TYPE_MSG)
 827            + desc->buf[i].dataSz;
 828        if (i+1 == sz) {
 829            /* this is the last input buffer, signal the HW with LC1 bit */
 830            desc->desc[desc->idx] |= FIFOL_TYPE_LC1;
 831        }
 832        desc->idx++;
 833
 834        vaddr[vidx] = CAAM_ADR_MAP(desc->buf[i].data, desc->buf[i].dataSz, 1);
 835        desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[vidx],
 836                desc->buf[i].dataSz);
 837        DEBUG_PRINT_ARRAY(vaddr[vidx], desc->buf[i].dataSz, "AES CMAC Input");
 838        vidx++;
 839    }
 840
 841    /* if there is no input buffers than add in a single FIFO LOAD to kick off
 842     * the operation */
 843    if (sz == 2) { /* only key and ctx buffer */
 844        desc->desc[desc->idx++] = CAAM_FIFO_L | FIFOL_TYPE_LC1 | CAAM_CLASS1 |
 845            FIFOL_TYPE_MSG;
 846        vaddr[vidx] = CAAM_ADR_MAP(0, 0, 0);
 847        desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[vidx], 0);
 848        vidx++;
 849    }
 850
 851    desc->desc[desc->idx++] = CAAM_STORE_CTX | CAAM_CLASS1 | 32;
 852    desc->desc[desc->idx++] = ctx;
 853
 854    do {
 855        err = caamDoJob(desc);
 856    } while (err == CAAM_WAITING);
 857    DEBUG_PRINT_ARRAY(vaddr[0], 32, "AES CMAC CTX");
 858
 859    vidx = 0;
 860    CAAM_ADR_UNMAP(vaddr[vidx++], desc->buf[1].data, desc->buf[1].dataSz, 1);
 861    CAAM_ADR_UNMAP(vaddr[vidx++], desc->buf[0].data, desc->buf[0].dataSz + macSz, 0);
 862    if (sz == 2) {
 863        CAAM_ADR_UNMAP(vaddr[vidx], 0, 0, 0);
 864    }
 865    else {
 866        for (i = 2; i < sz; i = i + 1) { /* unmap the input buffers */
 867            CAAM_ADR_UNMAP(vaddr[vidx++], desc->buf[i].data,
 868                    desc->buf[i].dataSz, 0);
 869        }
 870    }
 871
 872    return err;
 873}
 874
 875
 876int caamAead(DESCSTRUCT* desc, CAAM_BUFFER* buf, unsigned int args[4])
 877{
 878    int fifol = 0; /* last index for FIFO */
 879    Value ofst = 0;
 880    Error err;
 881    int ivSz = 0;
 882    void *iv, *key, *in, *out, *tag;
 883    int keySz;
 884    int tagSz;
 885    int inSz;
 886    int outSz;
 887    int idx = 0;
 888    void* aadCtxBuf = NULL;
 889    int state = CAAM_ALG_INITF; /* single shot mode */
 890    unsigned int aadSz;
 891
 892    if (desc->state != CAAM_ENC && desc->state != CAAM_DEC) {
 893        return CAAM_ARGS_E;
 894    }
 895
 896    keySz = buf[idx].Length;
 897    if (keySz != 16 && keySz != 24 && keySz != 32) {
 898        WOLFSSL_MSG("Bad AES key size found");
 899        return CAAM_ARGS_E;
 900    }
 901    aadSz = (args[0] >> 16) & 0xFFFF;
 902
 903    /* map and copy over key */
 904    key = (void*)buf[idx].TheAddress;
 905    desc->desc[desc->idx++] = (CAAM_KEY | CAAM_CLASS1 | CAAM_NWB) + keySz;
 906    desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(key, keySz);
 907    DEBUG_PRINT_ARRAY(key, keySz, "AES AEAD Key");
 908    idx++;
 909
 910    /* write operation, in the case of decryption add IVC to check tag */
 911    desc->desc[desc->idx] = CAAM_OP | CAAM_CLASS1 | desc->type |
 912             state | desc->state;
 913    if (desc->state == CAAM_DEC) {
 914        desc->desc[desc->idx] |= CAAM_ALG_IVC;
 915    }
 916    desc->idx++;
 917
 918    /* get IV if needed by algorithm */
 919    switch (desc->type) {
 920        case CAAM_AESGCM:
 921        {
 922            ivSz = buf[idx].Length;
 923            iv   = (void*)buf[idx].TheAddress;
 924            fifol = desc->idx;
 925            desc->desc[desc->idx++] = (CAAM_FIFO_L | CAAM_CLASS1 |
 926                FIFOL_TYPE_FC1 | FIFOL_TYPE_IV) + ivSz;
 927            desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(iv, ivSz);
 928            idx++;
 929         }
 930        break;
 931
 932        case CAAM_AESCCM:
 933        {
 934            ivSz = buf[idx].Length;
 935            iv   = (void*)buf[idx].TheAddress;
 936            desc->desc[desc->idx++] = (CAAM_LOAD_CTX | CAAM_CLASS1 | ofst) +
 937                ivSz;
 938            desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(iv, ivSz);
 939            idx++;
 940         }
 941         break;
 942
 943        default:
 944            WOLFSSL_MSG("Mode of AES not implemented");
 945            return CAAM_ARGS_E;
 946    }
 947    DEBUG_PRINT_ARRAY(iv, ivSz, "AES AEAD IV");
 948
 949    /* get input */
 950    inSz = buf[idx].Length;
 951    in   = (void*)buf[idx].TheAddress;
 952    DEBUG_PRINT_ARRAY(in, inSz, "AES AEAD Input");
 953    idx++;
 954
 955    /* set output */
 956    outSz = buf[idx].Length;
 957    out   = (void*)buf[idx].TheAddress;
 958    idx++;
 959
 960    /* TAG in/out */
 961    tagSz = buf[idx].Length;
 962    tag   = (void*)buf[idx].TheAddress;
 963    idx++;
 964
 965    /* set aad if present */
 966    if (aadSz > 0) {
 967        /* special AAD size setup of context register for CCM mode */
 968        if (desc->type == CAAM_AESCCM) {
 969            unsigned char* pt;
 970
 971            aadCtxBuf = CAAM_ADR_MAP(0, 4, 0);
 972            pt = (unsigned char*)aadCtxBuf;
 973            memset(pt, 0, 4);
 974            if (aadSz <= 0xFEFF) {
 975                pt[0] = (aadSz & 0xFF00) >> 8;
 976                pt[1] = (aadSz & 0x00FF);
 977                desc->desc[desc->idx++] = (CAAM_FIFO_L | CAAM_CLASS1 |
 978                    FIFOL_TYPE_AAD) + 2;
 979            }
 980            else {
 981                pt[0] = (aadSz >> 24) & 0xFF;
 982                pt[1] = (aadSz >> 16) & 0xFF;
 983                pt[2] = (aadSz >> 8 ) & 0xFF;
 984                pt[3] = aadSz & 0xFF;
 985                fifol = desc->idx;
 986                desc->desc[desc->idx++] = (CAAM_FIFO_L | CAAM_CLASS1 |
 987                    FIFOL_TYPE_AAD) + 4;
 988            }
 989            desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(aadCtxBuf, 4);
 990            CAAM_ADR_SYNC(aadCtxBuf, 4);
 991        }
 992
 993        /* Load in AAD */
 994        fifol = desc->idx;
 995        desc->desc[desc->idx++] = (CAAM_FIFO_L | CAAM_CLASS1 | FIFOL_TYPE_FC1 |
 996            FIFOL_TYPE_AAD) + aadSz;
 997        desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL((void*)buf[idx].TheAddress,
 998            buf[idx].Length);
 999        DEBUG_PRINT_ARRAY((void*)buf[idx].TheAddress, aadSz, "AES AEAD AAD");
1000        idx++;
1001    }
1002
1003    /* set input/output in descriptor */
1004    if (outSz > 0) {
1005        caamAddFIFOS(desc, out, outSz);
1006    }
1007
1008    if (inSz > 0) {
1009        fifol = desc->idx;
1010        caamAddFIFOL(desc, in, inSz, FIFOL_TYPE_FC1);
1011    }
1012
1013    if (desc->state == CAAM_DEC) {
1014        fifol = desc->idx;
1015        desc->desc[desc->idx++] = (CAAM_FIFO_L | FIFOL_TYPE_FC1 |
1016                                   CAAM_CLASS1 | FIFOL_TYPE_IVC) + tagSz;
1017        desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(tag, tagSz);
1018    }
1019
1020    /* remove FC1 and set LC1 for last FIFO load */
1021    desc->desc[fifol] &= ~FIFOL_TYPE_FC1;
1022    desc->desc[fifol] |= FIFOL_TYPE_LC1;
1023
1024    /* store updated IV / MAC */
1025    if (desc->state == CAAM_ENC) {
1026    switch (desc->type) {
1027        case CAAM_AESGCM:
1028            desc->desc[desc->idx++] = CAAM_STORE_CTX | CAAM_CLASS1 | tagSz;
1029            desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(tag, tagSz);
1030            break;
1031
1032        case CAAM_AESCCM:
1033            desc->desc[desc->idx++] = CAAM_STORE_CTX | CAAM_CLASS1 |
1034                (32 << 8) | tagSz;
1035            desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(tag, tagSz);
1036            break;
1037    }
1038    }
1039
1040    do {
1041        err = caamDoJob(desc);
1042    } while (err == CAAM_WAITING);
1043
1044    if (aadCtxBuf != NULL)
1045        CAAM_ADR_UNMAP(aadCtxBuf, 0, 4, 0);
1046
1047    DEBUG_PRINT_ARRAY(tag, tagSz, "AES AEAD Tag Out");
1048    DEBUG_PRINT_ARRAY(out, outSz, "AES AEAD Output");
1049    return err;
1050}
1051
1052
1053static int caamAesInternal(DESCSTRUCT* desc,
1054    unsigned int keyPhy, int keySz,
1055    unsigned int ivPhy,  int ivSz,
1056    unsigned int inPhy,  int inSz,
1057    unsigned int outPhy, int outSz)
1058{
1059    Value ofst = 0;
1060    Error err;
1061    int state = CAAM_ALG_UPDATE;
1062
1063    if (desc->state != CAAM_ENC && desc->state != CAAM_DEC) {
1064        return CAAM_ARGS_E;
1065    }
1066
1067    if (keySz != 16 && keySz != 24 && keySz != 32) {
1068        WOLFSSL_MSG("Bad AES key size found");
1069        return CAAM_ARGS_E;
1070    }
1071
1072    /* map and copy over key */
1073    desc->desc[desc->idx++] = (CAAM_KEY | CAAM_CLASS1 | CAAM_NWB) + keySz;
1074    desc->desc[desc->idx++] = keyPhy;
1075
1076    /* get IV if needed by algorithm */
1077    switch (desc->type) {
1078        case CAAM_AESECB:
1079            break;
1080
1081        case CAAM_AESCTR:
1082            ofst = 0x00001000;
1083            /* fall through because states are the same only the offset changes */
1084
1085        case CAAM_AESCBC:
1086        {
1087            int maxSz = 16; /* default to CBC/CTR max size */
1088
1089            if (ivSz != maxSz) {
1090                WOLFSSL_MSG("Invalid AES-CBC IV size\n");
1091                return CAAM_ARGS_E;
1092            }
1093
1094            desc->desc[desc->idx++] = (CAAM_LOAD_CTX | CAAM_CLASS1 | ofst) +
1095                    maxSz;
1096            desc->desc[desc->idx++] = ivPhy;
1097         }
1098         break;
1099
1100        default:
1101            WOLFSSL_MSG("Mode of AES not implemented");
1102            return CAAM_ARGS_E;
1103    }
1104
1105    /* write operation */
1106    desc->desc[desc->idx++] = CAAM_OP | CAAM_CLASS1 | desc->type |
1107             state | desc->state;
1108
1109    /* set input/output in descriptor */
1110    caamAddFIFOLPhy(desc, inPhy, inSz, FIFOL_TYPE_LC1);
1111    caamAddFIFOSPhy(desc, outPhy, outSz);
1112
1113    /* store updated IV */
1114    switch (desc->type) {
1115        case CAAM_AESCBC:
1116        case CAAM_AESCTR:
1117        if (ivSz > 0) {
1118            desc->desc[desc->idx++] = CAAM_STORE_CTX | CAAM_CLASS1 | ofst | 16;
1119            desc->desc[desc->idx++] = ivPhy;
1120        }
1121        break;
1122    }
1123
1124    do {
1125        err = caamDoJob(desc);
1126    } while (err == CAAM_WAITING);
1127
1128    return err;
1129}
1130
1131
1132/* Scattered memory, does a mapping for each variable. Less performant than
1133 * caamAesCombined.
1134 * AES operations follow the buffer sequence of KEY -> (IV) -> Input -> Output
1135 */
1136int caamAes(DESCSTRUCT* desc, CAAM_BUFFER* buf, unsigned int args[4])
1137{
1138    void *iv = NULL, *key, *in, *out;
1139    int ivSz = 0, keySz, inSz, outSz;
1140    int idx = 0;
1141
1142    unsigned int keyPhy = 0, inPhy = 0, outPhy = 0, ivPhy = 0;
1143
1144    /* map and copy over key */
1145    key    = (void*)buf[idx].TheAddress;
1146    keySz  = buf[idx].Length;
1147    keyPhy = CAAM_ADR_TO_PHYSICAL(key, keySz);
1148    idx++;
1149
1150    /* get IV if needed by algorithm */
1151    switch (desc->type) {
1152        case CAAM_AESECB:
1153            break;
1154
1155        case CAAM_AESCTR:
1156        case CAAM_AESCBC:
1157        {
1158            ivSz  = buf[idx].Length;
1159            iv    = (void*)buf[idx].TheAddress;
1160            ivPhy = CAAM_ADR_TO_PHYSICAL(iv, ivSz);
1161            idx++;
1162         }
1163         break;
1164
1165        default:
1166            WOLFSSL_MSG("Mode of AES not implemented");
1167            return CAAM_ARGS_E;
1168    }
1169
1170    /* get input */
1171    inSz  = buf[idx].Length;
1172    in    = (void*)buf[idx].TheAddress;
1173    inPhy = CAAM_ADR_TO_PHYSICAL(in, inSz);
1174    idx++;
1175
1176    /* set output */
1177    outSz  = buf[idx].Length;
1178    out    = (void*)buf[idx].TheAddress;
1179    outPhy = CAAM_ADR_TO_PHYSICAL(out, outSz);
1180    idx++;
1181
1182    return caamAesInternal(desc, keyPhy, keySz, ivPhy, ivSz, inPhy, inSz,
1183            outPhy, outSz);
1184}
1185
1186
1187/* When a single buffer is used [key] [in] [iv] [out] for optimization
1188 * phyMem is non 0 when the physical memory location is already known
1189 */
1190int caamAesCombined(DESCSTRUCT* desc, CAAM_BUFFER* buf, unsigned int args[4],
1191    unsigned int phyMem)
1192{
1193    int idx = 0;
1194    unsigned int keyPhy;
1195    int keySz, inSz, ivSz = 0, outSz;
1196    void* pt;
1197
1198    keySz = buf[idx].Length;
1199    pt    = (void*)buf[idx].TheAddress;
1200    idx++;
1201
1202    /* get IV if needed by algorithm */
1203    switch (desc->type) {
1204        case CAAM_AESECB:
1205            break;
1206
1207        case CAAM_AESCTR:
1208        case CAAM_AESCBC:
1209        {
1210            ivSz = buf[idx].Length;
1211            idx++;
1212         }
1213         break;
1214
1215        default:
1216            WOLFSSL_MSG("Mode of AES not implemented");
1217            return CAAM_ARGS_E;
1218    }
1219
1220    /* get input */
1221    inSz = buf[idx].Length;
1222    idx++;
1223
1224    /* set output */
1225    outSz = buf[idx].Length;
1226    idx++;
1227
1228    if (phyMem != 0) {
1229        keyPhy = phyMem;
1230    }
1231    else {
1232        keyPhy = CAAM_ADR_TO_PHYSICAL(pt, keySz + inSz + ivSz + outSz);
1233    }
1234
1235    return caamAesInternal(desc, keyPhy, keySz,
1236            keyPhy + keySz + inSz,ivSz,            /* IV */
1237            keyPhy + keySz, inSz,                  /* IN buffer */
1238            keyPhy + keySz + inSz + ivSz, outSz);  /* OUT buffer */
1239}
1240
1241
1242/* ECDSA generate black key
1243 *
1244 * return Success on success. All other return values are considered a fail
1245 *         case.
1246 */
1247int caamECDSAMake(DESCSTRUCT* desc, CAAM_BUFFER* buf, unsigned int args[4])
1248{
1249    Error err;
1250    unsigned int part = 0;
1251    unsigned int isBlackKey = 0;
1252    unsigned int pdECDSEL   = 0;
1253    unsigned int phys;
1254    void *vaddr[2];
1255
1256    if (args != NULL) {
1257        isBlackKey = args[0];
1258        pdECDSEL   = args[1];
1259    }
1260    vaddr[0] = NULL;
1261    vaddr[1] = NULL;
1262
1263    desc->desc[desc->idx++] = pdECDSEL;
1264    if (isBlackKey == CAAM_BLACK_KEY_SM) {
1265        unsigned char* pt;
1266
1267        /* create secure partition for private key out */
1268        part = caamFindUnusedPartition();
1269        if ((int)part < 0) {
1270            WOLFSSL_MSG("error finding an unused partition for new key");
1271            return -1;
1272        }
1273
1274        /* create and claim the partition */
1275        err = caamCreatePartition(&part, part, CAAM_SM_CSP | CAAM_SM_SMAP_LOCK |
1276                CAAM_SM_CSP | CAAM_SM_ALL_RW);
1277        if (err != Success) {
1278            WOLFSSL_MSG("error creating partition for secure ecc key");
1279            return -1;
1280        }
1281
1282        /* map secure partition to virtual address */
1283        phys = (CAAM_PAGE + (part << 12));
1284        pt = (unsigned char*)buf[0].TheAddress;
1285        pt[0] = (phys >> 24) & 0xFF;
1286        pt[1] = (phys >> 16) & 0xFF;
1287        pt[2] = (phys >> 8) & 0xFF;
1288        pt[3] = (phys) & 0xFF;
1289        desc->desc[desc->idx++] = phys;
1290    }
1291    else {
1292        vaddr[0] = CAAM_ADR_MAP(0, buf[0].Length, 0);
1293        desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[0], buf[0].Length);
1294
1295    }
1296    vaddr[1] = CAAM_ADR_MAP(0, buf[1].Length, 0);
1297    desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[1], buf[1].Length);
1298
1299    /* add protinfo to operation command */
1300    desc->startIdx = desc->idx;
1301
1302    /* add operation command               OPTYPE        PROTOID */
1303    desc->desc[desc->idx] = CAAM_OP | CAAM_PROT_UNIDI | desc->type;
1304    if (isBlackKey == CAAM_BLACK_KEY_SM || isBlackKey == CAAM_BLACK_KEY_CCM) {
1305        desc->desc[desc->idx] |= CAAM_PKHA_ENC_PRI_AESCCM;
1306    }
1307    if (isBlackKey == CAAM_BLACK_KEY_ECB) {
1308        desc->desc[desc->idx] |= CAAM_PKHA_ENC_PRI_AESECB;
1309    }
1310    desc->desc[desc->idx++] |= CAAM_PKHA_ECC;
1311
1312    do {
1313        err = caamDoJob(desc);
1314    } while (err == CAAM_WAITING);
1315
1316    if (isBlackKey == CAAM_BLACK_KEY_SM) {
1317        /* store partition number holding black keys */
1318        if (err != Success)
1319            caamFreePart(part);
1320        else
1321            args[2] = part;
1322    }
1323    else {
1324        /* copy non black keys out to buffers */
1325        CAAM_ADR_UNMAP(vaddr[0], buf[0].TheAddress, buf[0].Length, 1);
1326    }
1327    CAAM_ADR_UNMAP(vaddr[1], buf[1].TheAddress, buf[1].Length, 1);
1328
1329    return err;
1330}
1331
1332
1333
1334/* ECDSA verify signature
1335 *
1336 * return Success on success. All other return values are considered a fail
1337 *         case.
1338 */
1339int caamECDSAVerify(DESCSTRUCT* desc, CAAM_BUFFER* buf, int sz,
1340        unsigned int args[4])
1341{
1342    unsigned int isBlackKey = 0;
1343    unsigned int pdECDSEL   = 0;
1344    unsigned int msgSz = 0;
1345    unsigned int vidx = 0;
1346    unsigned int L;
1347    int i = 0;
1348    Error err;
1349    void *vaddr[MAX_ECDSA_VERIFY_ADDR];
1350
1351    if (args != NULL) {
1352        isBlackKey = args[0];
1353        pdECDSEL   = args[1];
1354        msgSz      = args[2];
1355    }
1356
1357    if (sz > MAX_ECDSA_VERIFY_ADDR) {
1358       return -1;
1359    }
1360
1361    if (pdECDSEL == 0) {
1362        return -1;
1363    }
1364    else {
1365        L = args[3]; /* keysize */
1366        desc->desc[desc->idx++] = pdECDSEL;
1367    }
1368
1369    /* public key */
1370    if (isBlackKey != CAAM_BLACK_KEY_SM) {
1371        vaddr[vidx] = CAAM_ADR_MAP(desc->buf[i].data, desc->buf[i].dataSz, 1);
1372        desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[vidx],
1373                desc->buf[i].dataSz);
1374        vidx = vidx + 1;
1375    }
1376    else {
1377        desc->desc[desc->idx++] = desc->buf[i].data;
1378    }
1379    i = i + 1;
1380
1381    /* message */
1382    vaddr[vidx] = CAAM_ADR_MAP(desc->buf[i].data, desc->buf[i].dataSz, 1);
1383    desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[vidx],
1384                desc->buf[i].dataSz);
1385    vidx = vidx + 1; i = i + 1;
1386
1387    /* r */
1388    vaddr[vidx] = CAAM_ADR_MAP(desc->buf[i].data, desc->buf[i].dataSz, 1);
1389    desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[vidx],
1390                desc->buf[i].dataSz);
1391    vidx = vidx + 1; i = i + 1;
1392
1393    /* s */
1394    vaddr[vidx] = CAAM_ADR_MAP(desc->buf[i].data, desc->buf[i].dataSz, 1);
1395    desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[vidx],
1396                desc->buf[i].dataSz);
1397    vidx = vidx + 1; i = i + 1;
1398
1399    /* tmp buffer */
1400    vaddr[vidx] = CAAM_ADR_MAP(0, 2*L, 0);
1401    desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[vidx], 2*L);
1402    if (msgSz > 0) {
1403        desc->desc[desc->idx++] = msgSz;
1404    }
1405
1406    /* add protinfo to operation command */
1407    desc->startIdx = desc->idx;
1408
1409    /* add operation command               OPTYPE        PROTOID */
1410    desc->desc[desc->idx] = CAAM_OP | CAAM_PROT_UNIDI | desc->type;
1411    if (msgSz > 0) {
1412        desc->desc[desc->idx] |= CAAM_ECDSA_MESREP_HASHED;
1413    }
1414    desc->desc[desc->idx++] |= CAAM_PKHA_ECC;
1415
1416    do {
1417        err = caamDoJob(desc);
1418    } while (err == CAAM_WAITING);
1419
1420    vidx = 0; i = 0;
1421    if (!isBlackKey) {
1422        CAAM_ADR_UNMAP(vaddr[vidx++], desc->buf[i].data, desc->buf[i].dataSz, 0);
1423    }
1424    i = i + 1;
1425
1426    /* msg , r, s, tmp */
1427    CAAM_ADR_UNMAP(vaddr[vidx++], desc->buf[i].data, desc->buf[i].dataSz, 0);
1428    i = i + 1;
1429    CAAM_ADR_UNMAP(vaddr[vidx++], desc->buf[i].data, desc->buf[i].dataSz, 0);
1430    i = i + 1;
1431    CAAM_ADR_UNMAP(vaddr[vidx++], desc->buf[i].data, desc->buf[i].dataSz, 0);
1432    i = i + 1;
1433    CAAM_ADR_UNMAP(vaddr[vidx++], 0, 2*L, 0);
1434
1435    return err;
1436}
1437
1438
1439/* ECDSA generate signature
1440 *
1441 * return Success on success. All other return values are considered a fail
1442 *         case.
1443 */
1444int caamECDSASign(DESCSTRUCT* desc, int sz, unsigned int args[4])
1445{
1446    Error err;
1447    unsigned int isBlackKey = 0;
1448    unsigned int pdECDSEL   = 0;
1449    unsigned int msgSz = 0;
1450    unsigned int vidx = 0;
1451    int i = 0;
1452    void *vaddr[MAX_ECDSA_SIGN_ADDR];
1453
1454    if ((args == NULL) || (sz > MAX_ECDSA_SIGN_ADDR)) {
1455        return -1;
1456    }
1457
1458    isBlackKey = args[0];
1459    pdECDSEL   = args[1];
1460    msgSz      = args[2];
1461    if (pdECDSEL == 0) {
1462        return -1;
1463    }
1464
1465    /* using parameters already in hardware */
1466    desc->desc[desc->idx++] = pdECDSEL;
1467
1468    /* private key */
1469    if (isBlackKey != CAAM_BLACK_KEY_SM) {
1470        vaddr[vidx] = CAAM_ADR_MAP(desc->buf[i].data, desc->buf[i].dataSz, 1);
1471        desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[vidx],
1472                desc->buf[i].dataSz);
1473    #if 0
1474        {
1475            unsigned int z; unsigned char* pt;
1476            printf("private :");
1477            pt = (unsigned char*)desc->buf[i].data;
1478            for (z = 0; z < desc->buf[i].dataSz; z++)
1479                printf("%02X", pt[z]);
1480            printf("\n");
1481        }
1482    #endif
1483        vidx++;
1484    }
1485    else {
1486        desc->desc[desc->idx++] = desc->buf[i].data;
1487    }
1488    i++;
1489
1490    for (; i < sz; i = i + 1) {
1491        vaddr[vidx] = CAAM_ADR_MAP(desc->buf[i].data, desc->buf[i].dataSz, 1);
1492    #if 0
1493        {
1494            unsigned int z;
1495            unsigned char *pt = (unsigned char*)vaddr[vidx];
1496            printf("input index %d/%d\n", i, sz);
1497            for (z = 0; z < desc->buf[i].dataSz; z++)
1498                printf("%02X", pt[z]);
1499            printf("\n");
1500        }
1501    #endif
1502        desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[vidx],
1503                desc->buf[i].dataSz);
1504        vidx++;
1505    }
1506
1507    desc->desc[desc->idx++] = msgSz;
1508
1509    /* add protinfo to operation command */
1510    desc->startIdx = desc->idx;
1511
1512    /* add operation command               OPTYPE        PROTOID */
1513    desc->desc[desc->idx] = CAAM_OP | CAAM_PROT_UNIDI | desc->type;
1514    if (isBlackKey == CAAM_BLACK_KEY_SM || isBlackKey == CAAM_BLACK_KEY_CCM) {
1515        /* set flag to use AES-CCM with black key */
1516        desc->desc[desc->idx] |= CAAM_PKHA_ENC_PRI_AESCCM;
1517    }
1518    if (isBlackKey == CAAM_BLACK_KEY_ECB) {
1519        /* set flag to use AES-ECB with black key */
1520        desc->desc[desc->idx] |= CAAM_PKHA_ENC_PRI_AESECB;
1521    }
1522
1523    /* add protinfo to operation command */
1524    desc->desc[desc->idx++] |= CAAM_ECDSA_MESREP_HASHED | CAAM_PKHA_ECC;
1525
1526    do {
1527        err = caamDoJob(desc);
1528    } while (err == CAAM_WAITING);
1529
1530    vidx = 0; i = 0;
1531    if (isBlackKey != CAAM_BLACK_KEY_SM) {
1532        CAAM_ADR_UNMAP(vaddr[vidx++], desc->buf[i].data, desc->buf[i].dataSz, 0);
1533    }
1534    i++;
1535
1536    /* msg */
1537    CAAM_ADR_UNMAP(vaddr[vidx++], desc->buf[i].data, desc->buf[i].dataSz, 0); i++;
1538
1539    /* copy out the r and s values */
1540    CAAM_ADR_UNMAP(vaddr[vidx++], desc->buf[i].data, desc->buf[i].dataSz, 1); i++;
1541    CAAM_ADR_UNMAP(vaddr[vidx++], desc->buf[i].data, desc->buf[i].dataSz, 1); i++;
1542
1543    return err;
1544}
1545
1546
1547/* ECDH generate shared secret
1548 *
1549 * return Success on success. All other return values are considered a fail
1550 *         case.
1551 */
1552int caamECDSA_ECDH(DESCSTRUCT* desc, int sz, unsigned int args[4])
1553{
1554    Error err;
1555    unsigned int isBlackKey = 0;
1556    unsigned int peerBlackKey = 0;
1557    unsigned int pdECDSEL   = 0;
1558    unsigned int vidx = 0;
1559    int i = 0;
1560    void* vaddr[sz];
1561
1562    if (args != NULL) {
1563        isBlackKey   = args[0];
1564        peerBlackKey = args[1];
1565        pdECDSEL     = args[2];
1566    }
1567
1568    if (pdECDSEL == 0) {
1569        return -1;
1570    }
1571    else {
1572        /* using parameters already in hardware */
1573        desc->desc[desc->idx++] = pdECDSEL;
1574    }
1575
1576    /* public key */
1577    if (peerBlackKey != CAAM_BLACK_KEY_SM) {
1578        vaddr[vidx] = CAAM_ADR_MAP(desc->buf[i].data, desc->buf[i].dataSz, 1);
1579        desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[vidx],
1580                desc->buf[i].dataSz);
1581        DEBUG_PRINT_ARRAY((void*)desc->buf[i].data, desc->buf[i].dataSz,
1582                "ECDH Public Key");
1583        vidx++;
1584    }
1585    else {
1586        desc->desc[desc->idx++] = desc->buf[i].data;
1587    }
1588    i++;
1589
1590    /* private key */
1591    if (isBlackKey != CAAM_BLACK_KEY_SM) {
1592        if (isBlackKey == CAAM_BLACK_KEY_CCM) {
1593            vaddr[vidx] = CAAM_ADR_MAP(desc->buf[i].data, desc->buf[i].dataSz +
1594                BLACK_KEY_MAC_SZ, 1);
1595            desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[vidx],
1596                desc->buf[i].dataSz + BLACK_KEY_MAC_SZ);
1597            DEBUG_PRINT_ARRAY((void*)desc->buf[i].data, desc->buf[i].dataSz +
1598                BLACK_KEY_MAC_SZ, "ECDH Private Key w/CCM ");
1599        }
1600        else {
1601            vaddr[vidx] = CAAM_ADR_MAP(desc->buf[i].data, desc->buf[i].dataSz, 1);
1602            desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[vidx],
1603                desc->buf[i].dataSz);
1604            DEBUG_PRINT_ARRAY((void*)desc->buf[i].data, desc->buf[i].dataSz,
1605                    "ECDH Private Key");
1606        }
1607        vidx++;
1608    }
1609    else {
1610        desc->desc[desc->idx++] = desc->buf[i].data;
1611    }
1612    i++;
1613
1614    /* shared output */
1615    vaddr[vidx] = CAAM_ADR_MAP(desc->buf[i].data, desc->buf[i].dataSz, 1);
1616    desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[vidx],
1617            desc->buf[i].dataSz);
1618    i++; vidx++;
1619
1620    /* add protinfo to operation command */
1621    desc->startIdx = desc->idx;
1622
1623    /* add operation command               OPTYPE        PROTOID */
1624    desc->desc[desc->idx] = CAAM_OP | CAAM_PROT_UNIDI | desc->type;
1625    if (isBlackKey == CAAM_BLACK_KEY_SM || isBlackKey == CAAM_BLACK_KEY_CCM) {
1626        desc->desc[desc->idx] |= CAAM_PKHA_ENC_PRI_AESCCM;
1627    }
1628    if (isBlackKey == CAAM_BLACK_KEY_ECB) {
1629        desc->desc[desc->idx] |= CAAM_PKHA_ENC_PRI_AESECB;
1630    }
1631
1632    /* add protinfo to operation command */
1633    desc->desc[desc->idx++] |= CAAM_PKHA_ECC;
1634
1635    do {
1636        err = caamDoJob(desc);
1637    } while (err == CAAM_WAITING);
1638
1639    vidx = 0; i = 0;
1640    if (pdECDSEL == 0) {
1641        /* unmap prime key */
1642        CAAM_ADR_UNMAP(vaddr[vidx], desc->buf[i].data, desc->buf[i].dataSz, 0);
1643        vidx++; i++;
1644    }
1645
1646    if (peerBlackKey != 1) {
1647        CAAM_ADR_UNMAP(vaddr[vidx], desc->buf[i].data, desc->buf[i].dataSz, 0);
1648        vidx++;
1649    }
1650    i++;
1651
1652    if (isBlackKey != CAAM_BLACK_KEY_SM) {
1653        CAAM_ADR_UNMAP(vaddr[vidx], desc->buf[i].data, desc->buf[i].dataSz, 0);
1654        vidx++;
1655    }
1656    i++;
1657    CAAM_ADR_UNMAP(vaddr[vidx], desc->buf[i].data, desc->buf[i].dataSz, 1);
1658    vidx++; i++;
1659
1660    if (pdECDSEL == 0) {
1661        /* unmap A , B*/
1662        CAAM_ADR_UNMAP(vaddr[vidx], desc->buf[i].data, desc->buf[i].dataSz, 0);
1663        vidx++; i++;
1664    }
1665    return err;
1666}
1667
1668
1669/******************************************************************************
1670  IODevice Start, Transfer and Finish Buffer
1671  ****************************************************************************/
1672/* If Entropy is not ready then return CAAM_WAITING */
1673static int caamTRNG(unsigned char *out, int outSz)
1674{
1675    int sz = 0;
1676
1677    CAAM_ADDRESS  reg; /* RTENT reg to read */
1678    unsigned char* local;
1679    int ofst = sizeof(unsigned int);
1680
1681    /* Check ENT_VAL bit to make sure entropy is ready */
1682    if ((CAAM_READ(caam.baseAddr + CAAM_RTMCTL) & CAAM_ENTVAL) != CAAM_ENTVAL) {
1683        return CAAM_WAITING;
1684    }
1685
1686    /* check state of TRNG */
1687    if ((CAAM_READ(caam.baseAddr + CAAM_RTSTATUS) & 0x0000FFFF) > 0) {
1688        WOLFSSL_MSG("RNG in a bad state");
1689        return Failure;
1690    }
1691
1692    /* read entropy from RTENT registers */
1693    reg   = caam.baseAddr + CAAM_RTENT0;
1694    sz    = outSz;
1695    local = out;
1696
1697    while (sz > 3 && reg <= caam.baseAddr + CAAM_RTENT_MAX) {
1698        unsigned int data = CAAM_READ(reg);
1699        *((unsigned int*)local) = data;
1700        reg    += ofst;
1701        local  += ofst;
1702        sz     -= ofst;
1703    }
1704
1705    if (reg > CAAM_RTENT_MAX && sz > 0) {
1706        return -1;
1707    }
1708
1709    /* handle non unsigned int size amount left over */
1710    if (sz > 0) {
1711        unsigned int tmp = CAAM_READ(reg);
1712        memcpy(local, (unsigned char*)&tmp, sz);
1713    }
1714
1715    /* read the max RTENT to trigger new entropy generation */
1716    if (reg != CAAM_RTENT_MAX) {
1717        CAAM_READ(caam.baseAddr + CAAM_RTENT_MAX);
1718    }
1719
1720    return Success;
1721}
1722
1723
1724/* out is the virtual address to store resulting RNG data in */
1725static int caamRNG(unsigned char *out, int outSz)
1726{
1727    DESCSTRUCT desc;
1728    int ret;
1729
1730    /* set up the job description for RNG initialization */
1731    caamDescInit(&desc, 0, NULL, NULL, 0);
1732    desc.desc[desc.idx++] = CAAM_OP | CAAM_CLASS1 | CAAM_RNG;
1733    desc.desc[desc.idx++] = (CAAM_FIFO_S | FIFOS_TYPE_RNG) + outSz;
1734    desc.desc[desc.idx++] = CAAM_ADR_TO_PHYSICAL(out, outSz);
1735
1736    do {
1737        ret = caamDoJob(&desc);
1738    } while (ret == CAAM_WAITING);
1739
1740    return ret;
1741}
1742
1743
1744int caamEntropy(unsigned char *out, int outSz)
1745{
1746    if (caam.vrs < 9) {
1747        /* can access TRNG directly */
1748        return caamTRNG(out, outSz);
1749    }
1750    else {
1751        /* use CAAM RNG as source of entropy */
1752        return caamRNG(out, outSz);
1753    }
1754}
1755
1756
1757/* cover a plain text key and make it a black key */
1758int caamKeyCover(DESCSTRUCT* desc, int sz, unsigned int args[4])
1759{
1760    Error err;
1761    unsigned int vidx = 0;
1762    int i = 0;
1763    void* vaddr[2];
1764
1765    (void)args;
1766
1767    if (sz > 2) {
1768        return -1;
1769    }
1770
1771    /* add input key */
1772    desc->desc[desc->idx++] = (CAAM_KEY | CAAM_CLASS1) +
1773        desc->buf[i].dataSz;
1774    vaddr[vidx] = CAAM_ADR_MAP(desc->buf[i].data, desc->buf[i].dataSz, 1);
1775    desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[vidx],
1776                desc->buf[i].dataSz);
1777    vidx++;
1778    i++;
1779
1780    /* add output */
1781    desc->desc[desc->idx++] = (CAAM_FIFO_S | CAAM_CLASS1 | args[0] |
1782        desc->state) + desc->buf[i].dataSz;
1783    vaddr[vidx] = CAAM_ADR_MAP(desc->buf[i].data, desc->buf[i].dataSz +
1784            BLACK_KEY_MAC_SZ, 0);
1785    desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[vidx],
1786            desc->buf[i].dataSz + BLACK_KEY_MAC_SZ);
1787
1788#if 0
1789    /* sanity check can we load it? used for debugging and testing */
1790    desc->desc[desc->idx++] = (CAAM_KEY | CAAM_CLASS1 | 0x500000) +
1791        desc->buf[i].dataSz;
1792    desc->desc[desc->idx++] = CAAM_ADR_TO_PHYSICAL(vaddr[1], desc->buf[1].dataSz);
1793#endif
1794
1795    do {
1796        err = caamDoJob(desc);
1797    } while (err == CAAM_WAITING);
1798
1799    CAAM_ADR_UNMAP(vaddr[0], desc->buf[0].data, desc->buf[0].dataSz, 0);
1800    CAAM_ADR_UNMAP(vaddr[1], desc->buf[1].data, desc->buf[1].dataSz +
1801            BLACK_KEY_MAC_SZ, 1);
1802    return err;
1803}
1804
1805
1806/******************************************************************************
1807  Init
1808  ****************************************************************************/
1809
1810/* initialize a DESCSTRUCT for an operation */
1811void caamDescInit(DESCSTRUCT* desc, int type, unsigned int args[4],
1812        CAAM_BUFFER* buf, int sz)
1813{
1814    int i;
1815
1816    desc->type   = type;
1817    desc->idx    = 0;
1818    desc->output = 0;
1819    desc->ctxOut = 0;
1820    desc->outputIdx = 0;
1821    desc->alignIdx = 0;
1822    desc->lastFifo = 0;
1823    if (args == NULL) {
1824        desc->state    = 0;
1825        desc->ctxSz    = 0;
1826        desc->inputSz  = 0;
1827    }
1828    else {
1829        desc->state    = args[0] & 0xFFFF;
1830        desc->ctxSz    = args[1] & 0xFFFF;
1831        desc->inputSz  = args[2];
1832    }
1833    desc->aadSz    = 0;
1834    desc->DescriptorCount = sz;
1835    desc->startIdx = 0;
1836    desc->desc[desc->idx++] = CAAM_HEAD; /* later will put size to header*/
1837
1838    for (i = 0; i < sz; i = i + 1) {
1839        desc->buf[i].data   = buf[i].TheAddress;
1840        desc->buf[i].dataSz = buf[i].Length;
1841    }
1842}
1843
1844
1845static int SetupJobRing(struct JobRing* r)
1846{
1847    /* get environment specific addresses to use for job rings */
1848    CAAM_SET_JOBRING_ADDR(&r->BaseAddr, &r->JobIn, &r->VirtualIn);
1849
1850    /* register the in/out and sizes of job ring */
1851    r->Desc     = r->JobIn + (CAAM_JOBRING_SIZE * sizeof(unsigned int));
1852    r->JobOut   = r->Desc + (CAAM_DESC_MAX * CAAM_JOBRING_SIZE);
1853
1854    CAAM_INIT_MUTEX(&caam.ring.jr_lock);
1855
1856    r->VirtualDesc = r->VirtualIn  + (CAAM_JOBRING_SIZE * sizeof(unsigned int));
1857    r->VirtualOut  = r->VirtualDesc + (CAAM_DESC_MAX * CAAM_JOBRING_SIZE);
1858
1859    memset(r->VirtualIn,   0, CAAM_JOBRING_SIZE * sizeof(unsigned int));
1860    memset(r->VirtualDesc, 0, CAAM_DESC_MAX * CAAM_JOBRING_SIZE);
1861    memset(r->VirtualOut,  0, 2 * CAAM_JOBRING_SIZE * sizeof(unsigned int));
1862
1863    #if defined(WOLFSSL_CAAM_DEBUG) || defined(WOLFSSL_CAAM_PRINT)
1864    printf("Setting JOB IN  address 0x%08X, size %d\n",
1865        (unsigned int)caam.ring.JobIn, CAAM_JOBRING_SIZE);
1866    printf("Setting JOB OUT address 0x%08X, size %d\n",
1867        (unsigned int)caam.ring.JobOut, CAAM_JOBRING_SIZE);
1868    printf("Setting DESC 0x%08X\n", (unsigned int)caam.ring.Desc);
1869    #endif
1870
1871    /* set the job ring in/out address's */
1872    CAAM_WRITE(r->BaseAddr + CAAM_IRBAR0, r->JobIn);
1873    CAAM_WRITE(r->BaseAddr + CAAM_ORBAR, r->JobOut);
1874
1875    /* Initialize job ring sizes */
1876    CAAM_WRITE(r->BaseAddr + CAAM_IRSR0, CAAM_JOBRING_SIZE);
1877    CAAM_WRITE(r->BaseAddr + CAAM_ORSR0, CAAM_JOBRING_SIZE);
1878
1879    /* if the job ring is busy, park it, flush it, and reset it */
1880    if (((CAAM_READ(r->BaseAddr + CAAM_STATUS) & 0x00000001) != 0) &&
1881        (CAAM_READ(r->BaseAddr + JRINTR_JR) != 0)) {
1882        unsigned int reg;
1883
1884    #if defined(WOLFSSL_CAAM_DEBUG) || defined(WOLFSSL_CAAM_PRINT)
1885        printf("Job ring is busy, trying to flush it\n");
1886    #endif
1887
1888        /* JRCR job ring command register */
1889        CAAM_WRITE(r->BaseAddr + JRCR_JR, 0x2); /* park it  */
1890        CAAM_WRITE(r->BaseAddr + JRCR_JR, 0x1); /* flush it */
1891        do {
1892            reg = CAAM_READ(r->BaseAddr + JRINTR_JR);
1893        } while (!(reg & 0x8) && (reg != 0)); /* bit 3 hot signals is halted */
1894
1895        if (reg != 0) {
1896            CAAM_WRITE(r->BaseAddr + JRCR_JR, 0x1); /* reset it */
1897        }
1898    }
1899    return 0;
1900}
1901
1902
1903int InitCAAM(void)
1904{
1905    Error ret;
1906
1907    /* map to memory addresses needed for accessing CAAM */
1908#if defined(WOLFSSL_CAAM_PRINT)
1909    printf("Using CAAM_BASE 0x%04X\n", CAAM_BASE);
1910#endif
1911    ret = CAAM_SET_BASEADDR(&caam.baseAddr);
1912    if (ret != 0) {
1913        return ret;
1914    }
1915
1916#if defined(WOLFSSL_CAAM_PRINT)
1917    printf("Using base address : 0x%04X\n", caam.baseAddr);
1918#endif
1919    ret = SetupJobRing(&caam.ring);
1920    if (ret != 0) {
1921        WOLFSSL_MSG("Error initializing job ring");
1922        INTERRUPT_Panic();
1923        return ret;
1924    }
1925#if defined(WOLFSSL_CAAM_PRINT)
1926    printf("Using base ring address : 0x%04X\n", caam.ring.BaseAddr);
1927#endif
1928
1929    /* get CHA era */
1930    caam.vrs = CAAM_READ(caam.ring.BaseAddr + CAAM_CHA_CCBVID) >> 24;
1931#if defined(WOLFSSL_CAAM_DEBUG) || defined(WOLFSSL_CAAM_PRINT)
1932    printf("CAAM version = %04X\n",
1933        CAAM_READ(caam.ring.BaseAddr + CAAM_VERSION_MS) & 0xFFFF);
1934    printf("CAAM era = %d\n", caam.vrs);
1935    printf("RNG revision number = %08X\n",
1936        CAAM_READ(caam.ring.BaseAddr + CAAM_CRNR_LS));
1937    printSecureMemoryInfo();
1938
1939    /* Check if CAAM supports AES-GCM */
1940    {
1941        unsigned int chaVerLS =
1942            CAAM_READ(caam.ring.BaseAddr + CAAM_CHA_VERSION_LS);
1943        printf("\nCHA support\n");
1944        printf("CHA Version LS = %04X\n", chaVerLS);
1945        if (!(chaVerLS & CAAM_AES_HIGH_PERFORMANCE)) {
1946            printf("High Performance AES module not supported, NO AES-GCM/XTS\n");
1947        }
1948        if (chaVerLS & CAAM_AES_LOW_POWER) {
1949            printf("Low Power AES module found\n");
1950        }
1951        printf("\n");
1952    }
1953#endif
1954
1955    /* when on i.MX8 with SECO the SECO has control of this */
1956    if (caam.vrs < 9) {
1957        /* set DECO watchdog to time out and flush jobs that cause the DECO to
1958           hang */
1959        CAAM_WRITE(caam.baseAddr + CAAM_RSTA,
1960                   CAAM_READ(caam.baseAddr + CAAM_RSTA) | 0x40000000);
1961
1962        /* start up RNG if not already started */
1963        if (caamInitRng(&caam) != 0) {
1964            WOLFSSL_MSG("Error initializing RNG");
1965            INTERRUPT_Panic();
1966            return -1;
1967        }
1968    }
1969
1970    WOLFSSL_MSG("Successfully initialized CAAM driver");
1971    #if defined(WOLFSSL_CAAM_DEBUG) || defined(WOLFSSL_CAAM_PRINT)
1972    fflush(stdout);
1973    #endif
1974    return 0;
1975}
1976
1977
1978int CleanupCAAM()
1979{
1980    caamFreeAllPart();
1981    CAAM_UNSET_JOBRING_ADDR(caam.ring.BaseAddr, caam.ring.JobIn,
1982        caam.ring.VirtualIn);
1983    CAAM_FREE_MUTEX(&caam.ring.jr_lock);
1984    CAAM_UNSET_BASEADDR(caam.baseAddr);
1985    return 0;
1986}
1987
1988#endif /* __INTEGRITY || INTEGRITY || __QNX__ || __QNXNTO__ */