Platarmboardfvpfvp Trusted Bootcvsplatarmboardfvp Rfvp R Trusted Bootc

Updated 1,222 Days AgoPublic

Actions

/*                                                            /*
 * Copyright (c) 2016-2020, ARM Limited and Contributors.  |   * Copyright (c) 2016-2021, ARM Limited and Contributors. 
 *                                                             *
 * SPDX-License-Identifier: BSD-3-Clause                       * SPDX-License-Identifier: BSD-3-Clause
 */                                                            */

#include <assert.h>                                           #include <assert.h>
#include <stdint.h>                                           #include <stdint.h>
#include <string.h>                                           #include <string.h>

#include <lib/mmio.h>                                         #include <lib/mmio.h>
#include <lib/fconf/fconf.h>                                  #include <lib/fconf/fconf.h>
#include <plat/arm/common/plat_arm.h>                         #include <plat/arm/common/plat_arm.h>
#include <plat/arm/common/fconf_nv_cntr_getter.h>             #include <plat/arm/common/fconf_nv_cntr_getter.h>
#include <plat/common/platform.h>                             #include <plat/common/platform.h>
#include <platform_def.h>                                     #include <platform_def.h>
#include <tools_share/tbbr_oid.h>                             #include <tools_share/tbbr_oid.h>

/*                                                            /*
 * Return the ROTPK hash in the following ASN.1 structure      * Return the ROTPK hash in the following ASN.1 structure 
 *                                                             *
 * AlgorithmIdentifier  ::=  SEQUENCE  {                       * AlgorithmIdentifier  ::=  SEQUENCE  {
 *     algorithm         OBJECT IDENTIFIER,                    *     algorithm         OBJECT IDENTIFIER,
 *     parameters        ANY DEFINED BY algorithm OPTIONAL     *     parameters        ANY DEFINED BY algorithm OPTIONAL
 * }                                                           * }
 *                                                             *
 * DigestInfo ::= SEQUENCE {                                   * DigestInfo ::= SEQUENCE {
 *     digestAlgorithm   AlgorithmIdentifier,                  *     digestAlgorithm   AlgorithmIdentifier,
 *     digest            OCTET STRING                          *     digest            OCTET STRING
 * }                                                           * }
 */                                                            */
int plat_get_rotpk_info(void *cookie, void **key_ptr, unsi    int plat_get_rotpk_info(void *cookie, void **key_ptr, unsi
                        unsigned int *flags)                                          unsigned int *flags)
{                                                             {
        return arm_get_rotpk_info(cookie, key_ptr, key_len            return arm_get_rotpk_info(cookie, key_ptr, key_len
}                                                             }

/*                                                            /*
 * Store a new non-volatile counter value.                     * Store a new non-volatile counter value.
 *                                                             *
 * On some FVP versions, the non-volatile counters are rea |   * On some FVP_R versions, the non-volatile counters are r
 * function will always fail.                                  * function will always fail.
 *                                                             *
 * Return: 0 = success, Otherwise = error                      * Return: 0 = success, Otherwise = error
 */                                                            */
int plat_set_nv_ctr(void *cookie, unsigned int nv_ctr)        int plat_set_nv_ctr(void *cookie, unsigned int nv_ctr)
{                                                             {
        const char *oid;                                              const char *oid;
        uintptr_t nv_ctr_addr;                                        uintptr_t nv_ctr_addr;

        assert(cookie != NULL);                                       assert(cookie != NULL);

        oid = (const char *)cookie;                                   oid = (const char *)cookie;
        if (strcmp(oid, TRUSTED_FW_NVCOUNTER_OID) == 0) {             if (strcmp(oid, TRUSTED_FW_NVCOUNTER_OID) == 0) {
                nv_ctr_addr = FCONF_GET_PROPERTY(cot, nv_c                    nv_ctr_addr = FCONF_GET_PROPERTY(cot, nv_c
                                                TRUSTED_NV                                                    TRUSTED_NV
        } else if (strcmp(oid, NON_TRUSTED_FW_NVCOUNTER_OI            } else if (strcmp(oid, NON_TRUSTED_FW_NVCOUNTER_OI
                nv_ctr_addr = FCONF_GET_PROPERTY(cot, nv_c                    nv_ctr_addr = FCONF_GET_PROPERTY(cot, nv_c
                                                NON_TRUSTE                                                    NON_TRUSTE
        } else {                                                      } else {
                return 1;                                                     return 1;
        }                                                             }

        mmio_write_32(nv_ctr_addr, nv_ctr);                           mmio_write_32(nv_ctr_addr, nv_ctr);

        /*                                                            /*
         * If the FVP models a locked counter then its val |           * If the FVP_R models a locked counter then its v
         * and the above write operation has been silently             * and the above write operation has been silently
         */                                                            */
        return (mmio_read_32(nv_ctr_addr) == nv_ctr) ? 0 :            return (mmio_read_32(nv_ctr_addr) == nv_ctr) ? 0 :
}                                                             }