/* IBM_PROLOG_BEGIN_TAG                                                   */
/* This is an automatically generated prolog.                             */
/*                                                                        */
/* $Source: src/usr/secureboot/trusted/tpmLogMgr.H $                      */
/*                                                                        */
/* OpenPOWER HostBoot Project                                             */
/*                                                                        */
/* Contributors Listed Below - COPYRIGHT 2015,2016                        */
/* [+] International Business Machines Corp.                              */
/*                                                                        */
/*                                                                        */
/* Licensed under the Apache License, Version 2.0 (the "License");        */
/* you may not use this file except in compliance with the License.       */
/* You may obtain a copy of the License at                                */
/*                                                                        */
/*     http://www.apache.org/licenses/LICENSE-2.0                         */
/*                                                                        */
/* Unless required by applicable law or agreed to in writing, software    */
/* distributed under the License is distributed on an "AS IS" BASIS,      */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
/* implied. See the License for the specific language governing           */
/* permissions and limitations under the License.                         */
/*                                                                        */
/* IBM_PROLOG_END_TAG                                                     */
/**
 * @file tpmLogMgr.H
 *
 * @brief Trustedboot TPM Event Log Manager
 *
 */

/////////////////////////////////////////////////////////////////
// NOTE: This file is exportable as TSS-Lite for skiboot/PHYP  //
/////////////////////////////////////////////////////////////////

#ifndef __TPMLOGMGR_H
#define __TPMLOGMGR_H
// -----------------------------------------------
// Includes
// -----------------------------------------------

#ifdef __HOSTBOOT_MODULE
#include <sys/sync.h>
#endif
#include "trustedboot.H"
#include "trustedTypes.H"

#ifdef __cplusplus
namespace TRUSTEDBOOT
{
#endif

    /// Event log header algorithms
    struct _TCG_EfiSpecIdEventAlgorithmSize
    {
        uint16_t     algorithmId;
        uint16_t     digestSize;
    } PACKED;
    typedef struct _TCG_EfiSpecIdEventAlgorithmSize
                    TCG_EfiSpecIdEventAlgorithmSize;

    /// Event log header event data
    struct _TCG_EfiSpecIdEventStruct
    {
        char         signature[16];
        uint32_t     platformClass;
        uint8_t      specVersionMinor;
        uint8_t      specVersionMajor;
        uint8_t      specErrata;
        uint8_t      uintnSize;
        uint32_t     numberOfAlgorithms;
        TCG_EfiSpecIdEventAlgorithmSize digestSizes[HASH_COUNT];
        uint8_t      vendorInfoSize;
        char         vendorInfo[0];
    } PACKED;
    typedef struct _TCG_EfiSpecIdEventStruct TCG_EfiSpecIdEventStruct;
    uint32_t TCG_EfiSpecIdEventStruct_size(TCG_EfiSpecIdEventStruct* val);

    enum {
        TPMLOG_BUFFER_SIZE   = 3584, ///< Size of event log buffer for HB
        TPMLOG_DEVTREE_SIZE  = 64*1024, ///< Size to allocate for OPAL
    };

    struct _TpmLogMgr
    {
        uint32_t logSize;        ///< Current byte size of log
        uint32_t logMaxSize;     ///< Space allocated for log entries
        uint8_t* newEventPtr;    ///< Pointer to location to add new event
        uint8_t* eventLogInMem;  ///< Event log allocated from memory
#ifdef __HOSTBOOT_MODULE
        uint64_t inMemlogBaseAddr; ///< Base address of log for dev tree
        uint64_t devtreeXscomAddr; ///< Devtree Xscom Address
        uint32_t devtreeI2cMasterOffset; ///< Devtree I2c Master Offset
        uint8_t eventLog[TPMLOG_BUFFER_SIZE]; ///< EventLog Buffer
#endif
        mutex_t  logMutex;       ///< Log mutex
    };
    typedef struct _TpmLogMgr TpmLogMgr;

#ifdef __HOSTBOOT_MODULE
    /**
     * @brief Initialize the log manager
     * @param[in/out] io_logMgr Return a pointer to the log manager
     * @return errlHndl_t NULL if successful, otherwise a pointer to the
     *       error log.
     */
    errlHndl_t TpmLogMgr_initialize(TpmLogMgr * io_logMgr);
#endif

    /**
     * @brief Initialize the log manager to use a pre-existing buffer
     * @param[in] val TpmLogMgr structure
     * @param[in] eventLogPtr Pointer to event log to use
     * @param[in] eventLogSize Allocated log buffer size
     * @return errlHndl_t NULL if successful, otherwise a pointer to the
     *       error log.
     */
    errlHndl_t TpmLogMgr_initializeUsingExistingLog(TpmLogMgr* val,
                                                    uint8_t* eventLogPtr,
                                                    uint32_t eventLogSize);

    /**
     * @brief Add a new event to the log
     * @param[in] val TpmLogMgr structure
     * @param[in] logEvent Event log entry to add
     * @return errlHndl_t NULL if successful, otherwise a pointer to the
     *       error log.
     */
    errlHndl_t TpmLogMgr_addEvent(TpmLogMgr* val, TCG_PCR_EVENT2* logEvent);

    /**
     * @brief Get current log size in bytes
     * @param[in] val TpmLogMgr structure
     * @return uint32_t Byte size of log
     */
    uint32_t TpmLogMgr_getLogSize(TpmLogMgr* val);

#ifdef __HOSTBOOT_MODULE
    /**
     * @brief Retrieve devtree information
     * @param[in] val TpmLogMgr structure
     * @param[in/out] io_logAddr TPM Log address
     * @param[out] o_allocationSize Total memory allocated for log
     * @param[out] o_xscomAddr Chip Xscom Address
     * @param[out] o_i2cMasterOffset I2c Master Offset
     * @return errlHndl_t NULL if successful, otherwise a pointer to the
     *       error log.
     * Function will allocate a new region in memory to store log
     *  for passing to opal
     */
     errlHndl_t TpmLogMgr_getDevtreeInfo(TpmLogMgr* val,
                                         uint64_t & io_logAddr,
                                         size_t & o_allocationSize,
                                         uint64_t & o_xscomAddr,
                                         uint32_t & o_i2cMasterOffset);

    /**
     * @brief Store TPM devtree node information
     * @param[in] val TpmLogMgr structure
     * @param[in] i_xscomAddr Chip Xscom Address
     * @param[in] i_i2cMasterOffset i2c Master Offset
     */
    void TpmLogMgr_setTpmDevtreeInfo(TpmLogMgr* val,
                                     uint64_t i_xscomAddr,
                                     uint32_t i_i2cMasterOffset);
#endif


    /**
     * @brief Calculate the log size in bytes by walking the log
     * @param[in] val TpmLogMgr structure
     * @return uint32_t Byte size of log
     */
    uint32_t TpmLogMgr_calcLogSize(TpmLogMgr* val);

    /**
     * @brief Get pointer to first event in eventLog past the header event
     * @param[in] val TpmLogMgr structure
     * @return uint8_t First event handle
     * @retval NULL On empty log
     * @retval !NULL First event handle
     */
    const uint8_t* TpmLogMgr_getFirstEvent(TpmLogMgr* val);

    /**
     * @brief Get pointer to next event in log and unmarshal log contents
     *        into i_eventLog
     *
     * @param[in] i_handle      Current event to unmarshal
     * @param[in] i_eventLog    EVENT2 structure to populate
     * @param[in] o_err         Indicates if an error occurred during
     *                          LogUnmarshal.
     *
     * @return uint8_t*     Pointer to the next event after i_handle
     * @retval NULL When val contains last entry in log
     * @retval !NULL When addition log entries available
     */
    const uint8_t* TpmLogMgr_getNextEvent(TpmLogMgr* val,
                                          const uint8_t* i_handle,
                                          TCG_PCR_EVENT2* i_eventLog,
                                          bool* o_err);

    /**
     * @brief Get a TCG_PCR_EVENT2 populated with required data
     *
     * @param[in] i_pcr PCR to write to
     * @param[in] i_algId_1 Algorithm to use
     * @param[in] i_digest_1 Digest value to write to PCR
     * @param[in] i_digestSize_1 Byte size of i_digest array
     * @param[in] i_algId_2 Algorithm to use
     * @param[in] i_digest_2 Digest value to write to PCR, NULL if not used
     * @param[in] i_digestSize_2 Byte size of i_digest array
     * @param[in] i_logType Event type
     * @param[in] i_logMsg Null terminated Log message
     *
     * @return TCG_PCR_EVENT2   PCR event log
     */
    TCG_PCR_EVENT2 TpmLogMgr_genLogEventPcrExtend(TPM_Pcr i_pcr,
                                                  TPM_Alg_Id i_algId_1,
                                                  const uint8_t* i_digest_1,
                                                  size_t i_digestSize_1,
                                                  TPM_Alg_Id i_algId_2,
                                                  const uint8_t* i_digest_2,
                                                  size_t i_digestSize_2,
						  uint32_t i_logType,
                                                  const char* i_logMsg);
#ifdef __HOSTBOOT_MODULE
    /**
     * @brief Dump contents of log to a trace
     * @param[in] val TpmLogMgr structure
     */
    void TpmLogMgr_dumpLog(TpmLogMgr* val);
#endif

    /**
     * @brief Return a pointer to the start of the log
     * @param[in] val TpmLogMgr structure
     * @return uint8_t* Pointer to the start of the TPM log
     */
    uint8_t* TpmLogMgr_getLogStartPtr(TpmLogMgr* val);


#ifdef __cplusplus
} // end TRUSTEDBOOT namespace
#endif

#endif