| // 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 |
| |
| #ifndef PLATFORM_H |
| #define PLATFORM_H |
| // |
| // |
| // Includes and Defines |
| // |
| #include "bool.h" |
| #include "stdint.h" |
| #include "TpmError.h" |
| #include "TpmBuildSwitches.h" |
| #define UNREFERENCED(a) ((void)(a)) |
| // |
| // |
| // Power Functions |
| // |
| // _plat__Signal_PowerOn |
| // |
| // Signal power on This signal is simulate by a RPC call |
| // |
| LIB_EXPORT int |
| _plat__Signal_PowerOn(void); |
| // |
| // |
| // _plat__Signal_Reset |
| // |
| // Signal reset This signal is simulate by a RPC call |
| // |
| LIB_EXPORT int |
| _plat__Signal_Reset(void); |
| // |
| // |
| // _plat__WasPowerLost() |
| // |
| // Indicates if the power was lost before a _TPM__Init(). |
| // |
| LIB_EXPORT BOOL |
| _plat__WasPowerLost(BOOL clear); |
| // |
| // |
| // _plat__Signal_PowerOff() |
| // |
| // Signal power off This signal is simulate by a RPC call |
| // |
| LIB_EXPORT void |
| _plat__Signal_PowerOff(void); |
| // |
| // |
| // Physical Presence Functions |
| // |
| // _plat__PhysicalPresenceAsserted() |
| // |
| // Check if physical presence is signaled |
| // |
| // |
| // |
| // |
| // Return Value Meaning |
| // |
| // TRUE if physical presence is signaled |
| // FALSE if physical presence is not signaled |
| // |
| LIB_EXPORT BOOL |
| _plat__PhysicalPresenceAsserted(void); |
| // |
| // |
| // _plat__Signal_PhysicalPresenceOn |
| // |
| // Signal physical presence on This signal is simulate by a RPC call |
| // |
| LIB_EXPORT void |
| _plat__Signal_PhysicalPresenceOn(void); |
| // |
| // |
| // _plat__Signal_PhysicalPresenceOff() |
| // |
| // Signal physical presence off This signal is simulate by a RPC call |
| // |
| LIB_EXPORT void |
| _plat__Signal_PhysicalPresenceOff(void); |
| // |
| // |
| // Command Canceling Functions |
| // |
| // _plat__IsCanceled() |
| // |
| // Check if the cancel flag is set |
| // |
| // Return Value Meaning |
| // |
| // TRUE if cancel flag is set |
| // FALSE if cancel flag is not set |
| // |
| LIB_EXPORT BOOL |
| _plat__IsCanceled(void); |
| // |
| // |
| // _plat__SetCancel() |
| // |
| // Set cancel flag. |
| // |
| LIB_EXPORT void |
| _plat__SetCancel(void); |
| // |
| // |
| // _plat__ClearCancel() |
| // |
| // Clear cancel flag |
| // |
| LIB_EXPORT void |
| _plat__ClearCancel( void); |
| // |
| // |
| // |
| // NV memory functions |
| // |
| // _plat__NvErrors() |
| // |
| // This function is used by the simulator to set the error flags in the NV subsystem to simulate an error in the |
| // NV loading process |
| // |
| LIB_EXPORT void |
| _plat__NvErrors( |
| BOOL recoverable, |
| BOOL unrecoverable |
| ); |
| // |
| // |
| // _plat__NVEnable() |
| // |
| // Enable platform NV memory NV memory is automatically enabled at power on event. This function is |
| // mostly for TPM_Manufacture() to access NV memory without a power on event |
| // |
| // Return Value Meaning |
| // |
| // 0 if success |
| // non-0 if fail |
| // |
| LIB_EXPORT int |
| _plat__NVEnable( |
| void *platParameter // IN: platform specific parameters |
| ); |
| // |
| // |
| // _plat__NVDisable() |
| // |
| // Disable platform NV memory NV memory is automatically disabled at power off event. This function is |
| // mostly for TPM_Manufacture() to disable NV memory without a power off event |
| // |
| LIB_EXPORT void |
| _plat__NVDisable(void); |
| // |
| // |
| // _plat__IsNvAvailable() |
| // |
| // Check if NV is available |
| // |
| // Return Value Meaning |
| // |
| // 0 NV is available |
| // 1 NV is not available due to write failure |
| // 2 NV is not available due to rate limit |
| // |
| LIB_EXPORT int |
| _plat__IsNvAvailable(void); |
| // |
| // |
| // _plat__NvCommit() |
| // |
| // Update NV chip |
| // |
| // |
| // |
| // |
| // Return Value Meaning |
| // |
| // 0 NV write success |
| // non-0 NV write fail |
| // |
| LIB_EXPORT int |
| _plat__NvCommit(void); |
| // |
| // |
| // _plat__NvMemoryRead() |
| // |
| // Read a chunk of NV memory |
| // |
| LIB_EXPORT void |
| _plat__NvMemoryRead( |
| unsigned int startOffset, // IN: read start |
| unsigned int size, // IN: size of bytes to read |
| void *data // OUT: data buffer |
| ); |
| // |
| // |
| // _plat__NvIsDifferent() |
| // |
| // This function checks to see if the NV is different from the test value. This is so that NV will not be written if |
| // it has not changed. |
| // |
| // Return Value Meaning |
| // |
| // TRUE the NV location is different from the test value |
| // FALSE the NV location is the same as the test value |
| // |
| LIB_EXPORT BOOL |
| _plat__NvIsDifferent( |
| unsigned int startOffset, // IN: read start |
| unsigned int size, // IN: size of bytes to compare |
| void *data // IN: data buffer |
| ); |
| // |
| // |
| // _plat__NvMemoryWrite() |
| // |
| // Write a chunk of NV memory |
| // |
| LIB_EXPORT void |
| _plat__NvMemoryWrite( |
| unsigned int startOffset, // IN: read start |
| unsigned int size, // IN: size of bytes to read |
| void *data // OUT: data buffer |
| ); |
| // |
| // |
| // _plat__NvMemoryMove() |
| // |
| // Move a chunk of NV memory from source to destination This function should ensure that if there overlap, |
| // the original data is copied before it is written |
| // |
| LIB_EXPORT void |
| _plat__NvMemoryMove( |
| unsigned int sourceOffset, // IN: source offset |
| unsigned int destOffset, // IN: destination offset |
| unsigned int size // IN: size of data being moved |
| ); |
| // |
| // |
| // _plat__SetNvAvail() |
| // |
| // Set the current NV state to available. This function is for testing purposes only. It is not part of the |
| // platform NV logic |
| // |
| LIB_EXPORT void |
| _plat__SetNvAvail(void); |
| // |
| // |
| // _plat__ClearNvAvail() |
| // |
| // Set the current NV state to unavailable. This function is for testing purposes only. It is not part of the |
| // platform NV logic |
| // |
| LIB_EXPORT void |
| _plat__ClearNvAvail(void); |
| // |
| // |
| // _plat__NvGetHandleVirtualOffset() |
| // |
| // If the specified handle represents a virtual NV index, this function returns |
| // the corresponding virtual offset. For all other handles, 0 is returned. |
| // |
| LIB_EXPORT uint32_t |
| _plat__NvGetHandleVirtualOffset(uint32_t handle); |
| // |
| // |
| // _plat__NvOffsetIsVirtual() |
| // |
| // |
| // Returns true iff the specified offset corresponds to virtual NV memory; if |
| // so, this offset must only be read using the _plat__NvVirtualMemoryRead() |
| // function below. |
| // |
| LIB_EXPORT BOOL |
| _plat__NvOffsetIsVirtual(unsigned int startOffset); |
| // |
| // |
| // _plat__NvVirtualMemoryRead() |
| // |
| // |
| // Equivalent of _plat__NvMemoryRead, but for virtual NV memory. Only offsets |
| // for which _plat__NvOffsetIsVirtual() returns true should be passed to this |
| // function. |
| // |
| LIB_EXPORT void |
| _plat__NvVirtualMemoryRead( |
| unsigned int startOffset, |
| unsigned int size, |
| void *data |
| ); |
| // |
| // |
| // Locality Functions |
| // |
| // _plat__LocalityGet() |
| // |
| // Get the most recent command locality in locality value form |
| // |
| LIB_EXPORT unsigned char |
| _plat__LocalityGet(void); |
| // |
| // |
| // _plat__LocalitySet() |
| // |
| // Set the most recent command locality in locality value form |
| // |
| LIB_EXPORT void |
| _plat__LocalitySet( |
| unsigned char locality |
| ); |
| // |
| // |
| // _plat__IsRsaKeyCacheEnabled() |
| // |
| // This function is used to check if the RSA key cache is enabled or not. |
| // |
| LIB_EXPORT int |
| _plat__IsRsaKeyCacheEnabled( |
| void |
| ); |
| // |
| // |
| // Clock Constants and Functions |
| // |
| // Assume that the nominal divisor is 30000 |
| // |
| #define CLOCK_NOMINAL 30000 |
| // |
| // A 1% change in rate is 300 counts |
| // |
| #define CLOCK_ADJUST_COARSE 300 |
| // |
| // |
| // A .1 change in rate is 30 counts |
| // |
| #define CLOCK_ADJUST_MEDIUM 30 |
| // |
| // A minimum change in rate is 1 count |
| // |
| #define CLOCK_ADJUST_FINE 1 |
| // |
| // The clock tolerance is +/-15% (4500 counts) Allow some guard band (16.7%) |
| // |
| #define CLOCK_ADJUST_LIMIT 5000 |
| // |
| // |
| // _plat__ClockReset() |
| // |
| // This function sets the current clock time as initial time. This function is called at a power on event to reset |
| // the clock |
| // |
| LIB_EXPORT void |
| _plat__ClockReset(void); |
| // |
| // |
| // _plat__ClockTimeFromStart() |
| // |
| // Function returns the compensated time from the start of the command when |
| // _plat__ClockTimeFromStart() was called. |
| // |
| LIB_EXPORT unsigned long long |
| _plat__ClockTimeFromStart( |
| void |
| ); |
| // |
| // |
| // _plat__ClockTimeElapsed() |
| // |
| // Get the time elapsed from current to the last time the _plat__ClockTimeElapsed() is called. For the first |
| // _plat__ClockTimeElapsed() call after a power on event, this call report the elapsed time from power on to |
| // the current call |
| // |
| LIB_EXPORT unsigned long long |
| _plat__ClockTimeElapsed(void); |
| // |
| // |
| // _plat__ClockAdjustRate() |
| // |
| // Adjust the clock rate |
| // |
| LIB_EXPORT void |
| _plat__ClockAdjustRate( |
| int adjust // IN: the adjust number. It could be |
| // positive or negative |
| ); |
| // |
| // |
| // |
| // Single Function Files |
| // |
| // _plat__GetEntropy() |
| // |
| // This function is used to get available hardware entropy. In a hardware implementation of this function, |
| // there would be no call to the system to get entropy. If the caller does not ask for any entropy, then this is |
| // a startup indication and firstValue should be reset. |
| // |
| // Return Value Meaning |
| // |
| // <0 hardware failure of the entropy generator, this is sticky |
| // >= 0 the returned amount of entropy (bytes) |
| // |
| LIB_EXPORT int32_t |
| _plat__GetEntropy( |
| unsigned char *entropy, // output buffer |
| uint32_t amount // amount requested |
| ); |
| |
| // |
| // Get firmware version numbers from the platform. |
| // |
| LIB_EXPORT void |
| _plat__GetFwVersion( |
| uint32_t *fw1, |
| uint32_t *fw2 |
| ); |
| |
| // A function to call after every successful TPM2_Startup. |
| LIB_EXPORT void |
| _plat__StartupCallback( |
| void |
| ); |
| |
| // |
| // Check if a non-PLATFORMCREATE index shall nevertheless be retained when |
| // performing TPM2_Clear. |
| // |
| LIB_EXPORT BOOL |
| _plat__ShallSurviveOwnerClear( |
| uint32_t index |
| ); |
| |
| // A function to call as part of every TPM2_Clear. |
| LIB_EXPORT void |
| _plat__OwnerClearCallback( |
| void |
| ); |
| |
| // A function to inform CR50 that NvIndexData (handle) has been changed. |
| LIB_EXPORT void |
| _plat__NvInformIndexDataChanged(uint32_t handle); |
| |
| int uart_printf(const char *format, ...); |
| #define ecprintf(format, args...) uart_printf(format, ## args); |
| |
| #endif |
