| // 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 <memory.h> |
| #include <stdio.h> |
| #include <string.h> |
| |
| #include "PlatformData.h" |
| #include "TpmError.h" |
| #include "assert.h" |
| |
| #ifndef EMBEDDED_MODE |
| #define FILE_BACKED_NV |
| #endif |
| |
| #if defined FILE_BACKED_NV |
| static FILE* s_NVFile; |
| #endif |
| static unsigned char s_NV[NV_MEMORY_SIZE]; |
| static BOOL s_NvIsAvailable; |
| static BOOL s_NV_unrecoverable; |
| static BOOL s_NV_recoverable; |
| // |
| // |
| // 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 |
| ) |
| { |
| s_NV_unrecoverable = unrecoverable; |
| s_NV_recoverable = recoverable; |
| } |
| // |
| // |
| // _plat__NVEnable() |
| // |
| // Enable NV memory. |
| // This version just pulls in data from a file. In a real TPM, with NV on chip, this function would verify the |
| // integrity of the saved context. If the NV memory was not on chip but was in something like RPMB, the NV |
| // state would be read in, decrypted and integrity checked. |
| // The recovery from an integrity failure depends on where the error occurred. It it was in the state that is |
| // discarded by TPM Reset, then the error is recoverable if the TPM is reset. Otherwise, the TPM must go |
| // into failure mode. |
| // |
| // Return Value Meaning |
| // |
| // 0 if success |
| // >0 if receive recoverable error |
| // <0 if unrecoverable error |
| // |
| LIB_EXPORT int |
| _plat__NVEnable( |
| void *platParameter // IN: platform specific parameter |
| ) |
| { |
| // Start assuming everything is OK |
| s_NV_unrecoverable = FALSE; |
| s_NV_recoverable = FALSE; |
| #ifdef FILE_BACKED_NV |
| if(s_NVFile != NULL) return 0; |
| // Try to open an exist NVChip file for read/write |
| s_NVFile = fopen("NVChip", "r+b"); |
| if(NULL != s_NVFile) |
| { |
| // See if the NVChip file is empty |
| fseek(s_NVFile, 0, SEEK_END); |
| if(0 == ftell(s_NVFile)) |
| s_NVFile = NULL; |
| } |
| if(s_NVFile == NULL) |
| { |
| // Initialize all the byte in the new file to 0 |
| memset(s_NV, 0, NV_MEMORY_SIZE); |
| // If NVChip file does not exist, try to create it for read/write |
| s_NVFile = fopen("NVChip", "w+b"); |
| // Start initialize at the end of new file |
| fseek(s_NVFile, 0, SEEK_END); |
| // Write 0s to NVChip file |
| fwrite(s_NV, 1, NV_MEMORY_SIZE, s_NVFile); |
| } |
| else |
| { |
| // If NVChip file exist, assume the size is correct |
| fseek(s_NVFile, 0, SEEK_END); |
| assert(ftell(s_NVFile) == NV_MEMORY_SIZE); |
| // read NV file data to memory |
| fseek(s_NVFile, 0, SEEK_SET); |
| assert(1 == fread(s_NV, NV_MEMORY_SIZE, 1, s_NVFile)); |
| } |
| #endif |
| // NV contents have been read and the error checks have been performed. For |
| // simulation purposes, use the signaling interface to indicate if an error is |
| // to be simulated and the type of the error. |
| if(s_NV_unrecoverable) |
| return -1; |
| return s_NV_recoverable; |
| } |
| // |
| // |
| // _plat__NVDisable() |
| // |
| // Disable NV memory |
| // |
| LIB_EXPORT void |
| _plat__NVDisable( |
| void |
| ) |
| { |
| #ifdef FILE_BACKED_NV |
| assert(s_NVFile != NULL); |
| // Close NV file |
| fclose(s_NVFile); |
| // Set file handle to NULL |
| // |
| s_NVFile = NULL; |
| #endif |
| return; |
| } |
| // |
| // |
| // _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 |
| ) |
| { |
| // NV is not available if the TPM is in failure mode |
| if(!s_NvIsAvailable) |
| return 1; |
| #ifdef FILE_BACKED_NV |
| if(s_NVFile == NULL) |
| return 1; |
| #endif |
| return 0; |
| } |
| // |
| // |
| // _plat__NvMemoryRead() |
| // |
| // Function: 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 |
| ) |
| { |
| assert(startOffset + size <= NV_MEMORY_SIZE); |
| // Copy data from RAM |
| memcpy(data, &s_NV[startOffset], size); |
| return; |
| } |
| // |
| // |
| // _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 read |
| void *data // IN: data buffer |
| ) |
| { |
| return (memcmp(&s_NV[startOffset], data, size) != 0); |
| } |
| // |
| // |
| // _plat__NvMemoryWrite() |
| // |
| // This function is used to update NV memory. The write is to a memory copy of NV. At the end of the |
| // current command, any changes are written to the actual NV memory. |
| // |
| LIB_EXPORT void |
| _plat__NvMemoryWrite( |
| unsigned int startOffset, // IN: write start |
| unsigned int size, // IN: size of bytes to write |
| void *data // OUT: data buffer |
| ) |
| { |
| assert(startOffset + size <= NV_MEMORY_SIZE); |
| // Copy the data to the NV image |
| memcpy(&s_NV[startOffset], data, size); |
| } |
| // |
| // |
| // _plat__NvMemoryMove() |
| // |
| // Function: 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 |
| ) |
| { |
| assert(sourceOffset + size <= NV_MEMORY_SIZE); |
| assert(destOffset + size <= NV_MEMORY_SIZE); |
| // Move data in RAM |
| memmove(&s_NV[destOffset], &s_NV[sourceOffset], size); |
| return; |
| } |
| // |
| // |
| // _plat__NvCommit() |
| // |
| // Update NV chip |
| // |
| // |
| // |
| // Return Value Meaning |
| // |
| // 0 NV write success |
| // non-0 NV write fail |
| // |
| LIB_EXPORT int |
| _plat__NvCommit( |
| void |
| ) |
| { |
| #ifdef FILE_BACKED_NV |
| // If NV file is not available, return failure |
| if(s_NVFile == NULL) |
| return 1; |
| // Write RAM data to NV |
| fseek(s_NVFile, 0, SEEK_SET); |
| fwrite(s_NV, 1, NV_MEMORY_SIZE, s_NVFile); |
| return 0; |
| #else |
| return 0; |
| #endif |
| } |
| // |
| // |
| // _plat__SetNvAvail() |
| // |
| // Set the current NV state to available. This function is for testing purpose only. It is not part of the |
| // platform NV logic |
| // |
| LIB_EXPORT void |
| _plat__SetNvAvail( |
| void |
| ) |
| { |
| s_NvIsAvailable = TRUE; |
| return; |
| } |
| // |
| // |
| // _plat__ClearNvAvail() |
| // |
| // Set the current NV state to unavailable. This function is for testing purpose only. It is not part of the |
| // platform NV logic |
| // |
| LIB_EXPORT void |
| _plat__ClearNvAvail( |
| void |
| ) |
| { |
| s_NvIsAvailable = FALSE; |
| return; |
| } |
