// This file was extracted from the TCG Published

// Trusted Platform Module Library

// Part 4: Supporting Routines

// Family "2.0"

// Level 00 Revision 01.16

// October 30, 2014

#include "InternalRoutines.h"

#include "Platform.h"

//          Functions

//

//           TimePowerOn()

//

//     This function initialize time info at _TPM_Init().

//

void

TimePowerOn(

    void

    )

{

    TPM_SU               orderlyShutDown;

    // Read orderly data info from NV memory

    NvReadReserved(NV_ORDERLY_DATA, &go);

    // Read orderly shut down state flag

    NvReadReserved(NV_ORDERLY, &orderlyShutDown);

    // If the previous cycle is orderly shut down, the value of the safe bit

    // the same as previously saved. Otherwise, it is not safe.

    if(orderlyShutDown == SHUTDOWN_NONE)

        go.clockSafe= NO;

    else

        go.clockSafe = YES;

    // Set the initial state of the DRBG

    CryptDrbgGetPutState(PUT_STATE);

    // Clear time since TPM power on

    g_time = 0;

    return;

}

//

//

//           TimeStartup()

//

//     This function updates the resetCount and restartCount components of TPMS_CLOCK_INFO structure at

//     TPM2_Startup().

//

void

TimeStartup(

    STARTUP_TYPE          type                // IN: start up type

    )

{

    if(type == SU_RESUME)

    {

        // Resume sequence

        gr.restartCount++;

    }

    else

    {

        if(type == SU_RESTART)

        {

             // Hibernate sequence

             gr.clearCount++;

             gr.restartCount++;

        }

        else

        {

             // Reset sequence

             // Increase resetCount

             gp.resetCount++;

              // Write resetCount to NV

              NvWriteReserved(NV_RESET_COUNT, &gp.resetCount);

              gp.totalResetCount++;

              // We do not expect the total reset counter overflow during the life

              // time of TPM. if it ever happens, TPM will be put to failure mode

              // and there is no way to recover it.

              // The reason that there is no recovery is that we don't increment

              // the NV totalResetCount when incrementing would make it 0. When the

              // TPM starts up again, the old value of totalResetCount will be read

              // and we will get right back to here with the increment failing.

              if(gp.totalResetCount == 0)

                  FAIL(FATAL_ERROR_INTERNAL);

              // Write total reset counter to NV

              NvWriteReserved(NV_TOTAL_RESET_COUNT, &gp.totalResetCount);

              // Reset restartCount

              gr.restartCount = 0;

         }

   }

   return;

}

//

//

//             TimeUpdateToCurrent()

//

//      This function updates the Time and Clock in the global TPMS_TIME_INFO structure.

//      In this implementation, Time and Clock are updated at the beginning of each command and the values

//      are unchanged for the duration of the command.

//      Because Clock updates may require a write to NV memory, Time and Clock are not allowed to advance if

//      NV is not available. When clock is not advancing, any function that uses Clock will fail and return

//      TPM_RC_NV_UNAVAILABLE or TPM_RC_NV_RATE.

//      This implementations does not do rate limiting. If the implementation does do rate limiting, then the Clock

//      update should not be inhibited even when doing rather limiting.

//

void

TimeUpdateToCurrent(

   void

   )

{

   UINT64          oldClock;

   UINT64          elapsed;

#define CLOCK_UPDATE_MASK ((1ULL << NV_CLOCK_UPDATE_INTERVAL)- 1)

   // Can't update time during the dark interval or when rate limiting.

   if(NvIsAvailable() != TPM_RC_SUCCESS)

       return;

   // Save the old clock value

   oldClock = go.clock;

   // Update the time info to current

   elapsed = _plat__ClockTimeElapsed();

   go.clock += elapsed;

   g_time += elapsed;

   // Check to see if the update has caused a need for an nvClock update

   // CLOCK_UPDATE_MASK is measured by second, while the value in go.clock is

   // recorded by millisecond. Align the clock value to second before the bit

//

   // operations

   if( ((go.clock/1000) | CLOCK_UPDATE_MASK)

           > ((oldClock/1000) | CLOCK_UPDATE_MASK))

   {

       // Going to update the time state so the safe flag

       // should be set

       go.clockSafe = YES;

         // Get the DRBG state before updating orderly data

         CryptDrbgGetPutState(GET_STATE);

         NvWriteReserved(NV_ORDERLY_DATA, &go);

   }

   // Call self healing logic for dictionary attack parameters

   DASelfHeal();

   return;

}

//

//

//           TimeSetAdjustRate()

//

//      This function is used to perform rate adjustment on Time and Clock.

//

void

TimeSetAdjustRate(

   TPM_CLOCK_ADJUST          adjust            // IN: adjust constant

   )

{

   switch(adjust)

   {

       case TPM_CLOCK_COARSE_SLOWER:

           _plat__ClockAdjustRate(CLOCK_ADJUST_COARSE);

           break;

       case TPM_CLOCK_COARSE_FASTER:

           _plat__ClockAdjustRate(-CLOCK_ADJUST_COARSE);

           break;

       case TPM_CLOCK_MEDIUM_SLOWER:

           _plat__ClockAdjustRate(CLOCK_ADJUST_MEDIUM);

           break;

       case TPM_CLOCK_MEDIUM_FASTER:

           _plat__ClockAdjustRate(-CLOCK_ADJUST_MEDIUM);

           break;

       case TPM_CLOCK_FINE_SLOWER:

           _plat__ClockAdjustRate(CLOCK_ADJUST_FINE);

           break;

       case TPM_CLOCK_FINE_FASTER:

           _plat__ClockAdjustRate(-CLOCK_ADJUST_FINE);

           break;

       case TPM_CLOCK_NO_CHANGE:

           break;

       default:

           pAssert(FALSE);

           break;

   }

   return;

}

//

//

//           TimeGetRange()

//

//      This function is used to access TPMS_TIME_INFO. The TPMS_TIME_INFO structure is treaded as an

//      array of bytes, and a byte offset and length determine what bytes are returned.

//

//      Error Returns                   Meaning

//

//      TPM_RC_RANGE                    invalid data range

//

TPM_RC

TimeGetRange(

   UINT16              offset,             // IN: offset in TPMS_TIME_INFO

   UINT16              size,               // IN: size of data

   TIME_INFO          *dataBuffer          // OUT: result buffer

   )

{

   TPMS_TIME_INFO            timeInfo;

   UINT16                    infoSize;

   BYTE                      infoData[sizeof(TPMS_TIME_INFO)];

   BYTE                      *buffer;

   INT32                     bufferSize;

   // Fill TPMS_TIME_INFO structure

   timeInfo.time = g_time;

   TimeFillInfo(&timeInfo.clockInfo);

   // Marshal TPMS_TIME_INFO to canonical form

   buffer = infoData;

   bufferSize = sizeof(TPMS_TIME_INFO);

   infoSize = TPMS_TIME_INFO_Marshal(&timeInfo, &buffer, &bufferSize);

   // Check if the input range is valid

   if(offset + size > infoSize) return TPM_RC_RANGE;

   // Copy info data to output buffer

   MemoryCopy(dataBuffer, infoData + offset, size, sizeof(TIME_INFO));

   return TPM_RC_SUCCESS;

}

//

//

//          TimeFillInfo

//

//      This function gathers information to fill in a TPMS_CLOCK_INFO structure.

//

void

TimeFillInfo(

   TPMS_CLOCK_INFO           *clockInfo

   )

{

   clockInfo->clock = go.clock;

   clockInfo->resetCount = gp.resetCount;

   clockInfo->restartCount = gr.restartCount;

   // If NV is not available, clock stopped advancing and the value reported is

   // not "safe".

   if(NvIsAvailable() == TPM_RC_SUCCESS)

       clockInfo->safe = go.clockSafe;

   else

       clockInfo->safe = NO;

   return;

}