Index: firmware/App/Services/NVMgmtDD.c =================================================================== diff -u -r0face6417892ea9de28d146bf88d44a9f30cf2a4 -re17e1dc97bf8878056f1f7e4aa861c2448db52bc --- firmware/App/Services/NVMgmtDD.c (.../NVMgmtDD.c) (revision 0face6417892ea9de28d146bf88d44a9f30cf2a4) +++ firmware/App/Services/NVMgmtDD.c (.../NVMgmtDD.c) (revision e17e1dc97bf8878056f1f7e4aa861c2448db52bc) @@ -27,58 +27,58 @@ // ********** private definitions ********** -#define COMMAND_TIME_OUT (1 * MS_PER_SECOND) ///< Timeout for an EEPROM or RTC command in ms. /// EEPROM functions use the buffer length as the size of U32. So before send the length to any of FAPI functions, it should be divided by 4. #define EEPROM_OPS_SIZE_OF_CONVERTER 4 +#define COMMAND_TIME_OUT (1 * MS_PER_SECOND) ///< Timeout for an EEPROM or RTC command in ms. -/// NVDataMgmt Exec states enumeration. -typedef enum NVDataMgmt_Exec_State +/// NVM Exec states enumeration. +typedef enum NVM_Exec_State { - NVDATAMGMT_EXEC_STATE_IDLE = 0, ///< Exec state Idle. - NVDATAMGMT_EXEC_STATE_WRITE_TO_EEPROM, ///< Exec state write to EEPROM. - NVDATAMGMT_EXEC_STATE_VERIFY_EEPROM_WRITE, ///< Exec state verify EEPROM write. - NVDATAMGMT_EXEC_STATE_READ_FROM_EEPROM, ///< Exec state read from EEPROM. - NVDATAMGMT_EXEC_STATE_ERASE_EEPROM, ///< Exec state erase EEPROM. - NUM_OF_NVDATAMGMT_EXEC_STATES ///< Total number of exec states. -} NVDATAMGMT_EXEC_STATE_T; + NVM_EXEC_STATE_IDLE = 0, ///< Exec state Idle. + NVM_EXEC_STATE_WRITE_TO_EEPROM, ///< Exec state write to EEPROM. + NVM_EXEC_STATE_VERIFY_EEPROM_WRITE, ///< Exec state verify EEPROM write. + NVM_EXEC_STATE_READ_FROM_EEPROM, ///< Exec state read from EEPROM. + NVM_EXEC_STATE_ERASE_EEPROM, ///< Exec state erase EEPROM. + NUM_OF_NVM_EXEC_STATES ///< Total number of exec states. +} NVM_EXEC_STATE_T; -/// NVDataMgmt write record validity check states -typedef enum NVDataMgmt_Write_Record_Validity_Check +/// NVM write record validity check states +typedef enum NVM_Write_Record_Validity_Check { - NVDATAMGMT_RECORD_NOT_CHECKED = 0, ///< NVDataMgmt (written) record not checked. - NVDATAMGMT_RECORD_VALID, ///< NVDataMgmt record is valid. - NVDATAMGMT_RECORD_NOT_VALID, ///< NVDataMgmt record is not valid. - NUM_OF_NVDATAMGMT_RECORD_VALIDITY_CHECK ///< Number of NVDataMgmt validity check states. -} RECORD_VALIDITY_CHECK_T; + NVM_RECORD_NOT_CHECKED = 0, ///< NVM (written) record not checked. + NVM_RECORD_VALID, ///< NVM record is valid. + NVM_RECORD_NOT_VALID, ///< NVM record is not valid. + NUM_OF_NVM_RECORD_VALIDITY_CHECK ///< Number of NVM validity check states. +} NVM_RECORD_VALIDITY_CHECK_T; // ********** private data ********** -static NVDATAMGMT_EXEC_STATE_T nvDataMgmtExecState; ///< NVDataMgmt exec state variable. -static volatile BOOL powerOffIsImminent; ///< Power off warning has been signaled. Non-volatile memory operations should be completed ASAP and then ceased. -static RECORD_VALIDITY_CHECK_T writtenRecordStatus; ///< Record data write validity check. -static U08 writtenRecordCheckBuffer[ MAX_EEPROM_WRITE_BUFFER_BYTES ]; ///< Written record validity check buffer. -static U32 currentTime; ///< Current time. -static U32 recordAddressOffset; ///< Record address offset. +static NVM_EXEC_STATE_T nvmExecState; ///< NVM exec state variable. +static volatile BOOL powerOffIsImminent; ///< Power off warning has been signaled. Non-volatile memory operations should be completed ASAP and then ceased. +static NVM_RECORD_VALIDITY_CHECK_T writtenRecordStatus; ///< Record data write validity check. +static U32 currentTime; ///< Current time. +static U32 recordAddressOffset; ///< Record address offset. +static U08 writtenRecordCheckBuffer[ MAX_EEPROM_WRITE_BUFFER_BYTES ]; ///< Written record validity check buffer. // ********** private function prototypes ********** // Exec functions -static NVDATAMGMT_EXEC_STATE_T handleExecIdleState( void ); -static NVDATAMGMT_EXEC_STATE_T handleExecEraseState( void ); -static NVDATAMGMT_EXEC_STATE_T handleExecWriteToEEPROMState( void ); -static NVDATAMGMT_EXEC_STATE_T handleExecReadFromEEPROMState( void ); -static NVDATAMGMT_EXEC_STATE_T handleExecVerifyEEPROMWriteState( void ); +static NVM_EXEC_STATE_T handleExecIdleState( void ); +static NVM_EXEC_STATE_T handleExecEraseState( void ); +static NVM_EXEC_STATE_T handleExecWriteToEEPROMState( void ); +static NVM_EXEC_STATE_T handleExecReadFromEEPROMState( void ); +static NVM_EXEC_STATE_T handleExecVerifyEEPROMWriteState( void ); // Helper functions -static BOOL didCommandTimeout( NVDATAMGMT_EXEC_STATE_T state ); +static BOOL didCommandTimeout( NVM_EXEC_STATE_T state ); void initNVMgmtDD( void ) { - nvDataMgmtExecState = NVDATAMGMT_EXEC_STATE_IDLE; + nvmExecState = NVM_EXEC_STATE_IDLE; powerOffIsImminent = FALSE; currentTime = 0; - writtenRecordStatus = NVDATAMGMT_RECORD_NOT_CHECKED; + writtenRecordStatus = NVM_RECORD_NOT_CHECKED; recordAddressOffset = 0; initNVDriver(); @@ -103,38 +103,38 @@ /*********************************************************************//** * @brief - * The execNVDataMgmt runs the NVDataMgmt main tasks. - * @details Inputs: nvDataMgmtExecState - * @details Outputs: nvDataMgmtExecState + * The execNVM runs the NVM main tasks. + * @details Inputs: nvmExecState + * @details Outputs: nvmExecState * @return none *************************************************************************/ -void execNVDataMgmt( void ) +void execNVM( void ) { - switch ( nvDataMgmtExecState ) + switch ( nvmExecState ) { - case NVDATAMGMT_EXEC_STATE_IDLE: - nvDataMgmtExecState = handleExecIdleState(); + case NVM_EXEC_STATE_IDLE: + nvmExecState = handleExecIdleState(); break; - case NVDATAMGMT_EXEC_STATE_ERASE_EEPROM: - nvDataMgmtExecState = handleExecEraseState(); + case NVM_EXEC_STATE_ERASE_EEPROM: + nvmExecState = handleExecEraseState(); break; - case NVDATAMGMT_EXEC_STATE_WRITE_TO_EEPROM: - nvDataMgmtExecState = handleExecWriteToEEPROMState(); + case NVM_EXEC_STATE_WRITE_TO_EEPROM: + nvmExecState = handleExecWriteToEEPROMState(); break; - case NVDATAMGMT_EXEC_STATE_READ_FROM_EEPROM: - nvDataMgmtExecState = handleExecReadFromEEPROMState(); + case NVM_EXEC_STATE_READ_FROM_EEPROM: + nvmExecState = handleExecReadFromEEPROMState(); break; - case NVDATAMGMT_EXEC_STATE_VERIFY_EEPROM_WRITE: - nvDataMgmtExecState = handleExecVerifyEEPROMWriteState(); + case NVM_EXEC_STATE_VERIFY_EEPROM_WRITE: + nvmExecState = handleExecVerifyEEPROMWriteState(); break; default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_NVM_INVALID_EXEC_STATE, ( U32 )nvDataMgmtExecState ); - nvDataMgmtExecState = NVDATAMGMT_EXEC_STATE_IDLE; + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_NVM_INVALID_EXEC_STATE, ( U32 )nvmExecState ); + nvmExecState = NVM_EXEC_STATE_IDLE; break; } } @@ -147,15 +147,15 @@ * @details Outputs: none * @return next state *************************************************************************/ -static NVDATAMGMT_EXEC_STATE_T handleExecIdleState ( void ) +static NVM_EXEC_STATE_T handleExecIdleState ( void ) { - NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_IDLE; + NVM_EXEC_STATE_T state = NVM_EXEC_STATE_IDLE; BOOL areQueuesNotEmpty = FALSE; - NVDATAMGMT_OPERATION_STATE_T ops; + NVM_OPERATION_T ops; U32 recordFlashAddress; U08* bufferAddress; PROCESS_RECORD_JOB_T recordCurrentJob; - RECORD_JOBS_STATE_T job; + NVM_RECORD_TYPE_T job; PROCESS_RECORD_SPECS_T jobSpecs; // If power off command has been issued, do not process any new jobs @@ -183,31 +183,31 @@ { switch ( ops ) { - case NVDATAMGMT_ERASE_SECTOR: + case NVM_OPERATION_ERASE: eraseSector( (U32*)recordFlashAddress ); - state = NVDATAMGMT_EXEC_STATE_ERASE_EEPROM; + state = NVM_EXEC_STATE_ERASE_EEPROM; break; - case NVDATAMGMT_WRITE: + case NVM_OPERATION_WRITE: writeSector( (U32*)recordFlashAddress, (U08*)bufferAddress, MAX_EEPROM_WRITE_BUFFER_BYTES ); currentTime = getMSTimerCount(); - state = NVDATAMGMT_EXEC_STATE_WRITE_TO_EEPROM; + state = NVM_EXEC_STATE_WRITE_TO_EEPROM; break; - case NVDATAMGMT_READ: + case NVM_OPERATION_READ: readSector( (U32*)recordFlashAddress, (U32*)bufferAddress, ( jobSpecs.sizeofRecord / EEPROM_OPS_SIZE_OF_CONVERTER ) ); currentTime = getMSTimerCount(); - state = NVDATAMGMT_EXEC_STATE_READ_FROM_EEPROM; + state = NVM_EXEC_STATE_READ_FROM_EEPROM; break; default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_NVM_INVALID_OPS, ( U32 )nvDataMgmtExecState ); + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_NVM_INVALID_OPS, ( U32 )nvmExecState ); break; } } // Update Self Test Read Records Flag - if ( ( TRUE == isRecordQueueEmpty() ) && ( state == NVDATAMGMT_EXEC_STATE_IDLE ) ) + if ( ( TRUE == isRecordQueueEmpty() ) && ( state == NVM_EXEC_STATE_IDLE ) ) { updateSelfTestReadRecordsFlag( TRUE ); } @@ -227,14 +227,14 @@ * @details Outputs: none * @return next state *************************************************************************/ -static NVDATAMGMT_EXEC_STATE_T handleExecEraseState ( void ) +static NVM_EXEC_STATE_T handleExecEraseState ( void ) { - NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_ERASE_EEPROM; + NVM_EXEC_STATE_T state = NVM_EXEC_STATE_ERASE_EEPROM; BOOL timeoutStatus = didCommandTimeout( state ); if ( TRUE == isFlashReady() || timeoutStatus == TRUE ) { - state = NVDATAMGMT_EXEC_STATE_IDLE; + state = NVM_EXEC_STATE_IDLE; } return state; @@ -250,19 +250,19 @@ * writtenRecordStatus * @return next state of the state machine *************************************************************************/ -static NVDATAMGMT_EXEC_STATE_T handleExecWriteToEEPROMState ( void ) +static NVM_EXEC_STATE_T handleExecWriteToEEPROMState ( void ) { - NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_WRITE_TO_EEPROM; + NVM_EXEC_STATE_T state = NVM_EXEC_STATE_WRITE_TO_EEPROM; BOOL timeoutStatus = didCommandTimeout( state ); PROCESS_RECORD_JOB_T recordCurrentJob = getCurrentProcessRecordJob(); - RECORD_JOBS_STATE_T job = recordCurrentJob.recordJob; + NVM_RECORD_TYPE_T job = recordCurrentJob.recordJob; PROCESS_RECORD_SPECS_T jobSpecs = getProcessRecord ( job ); // Check if the fapi has finished if ( TRUE == isFlashReady() ) { // Check the integrity of data (the 16 bytes that were written to EEPROM should be read and be checked for each byte) - if ( writtenRecordStatus == NVDATAMGMT_RECORD_NOT_CHECKED ) + if ( writtenRecordStatus == NVM_RECORD_NOT_CHECKED ) { currentTime = getMSTimerCount(); U32 recordFlashAddress = jobSpecs.recordFlashAddress + recordAddressOffset; @@ -274,14 +274,14 @@ // Issue a FAPI read command but only the bytes that were written, so use maxBufferLength readSector( (U32*)recordFlashAddress, (U32*)writtenRecordCheckBuffer, maxBufferLength ); - state = NVDATAMGMT_EXEC_STATE_VERIFY_EEPROM_WRITE; + state = NVM_EXEC_STATE_VERIFY_EEPROM_WRITE; } - else if ( writtenRecordStatus == NVDATAMGMT_RECORD_VALID ) + else if ( writtenRecordStatus == NVM_RECORD_VALID ) { // If the data is valid, and if it is at the end of the write, change to idle if ( jobSpecs.sizeofRecord == recordAddressOffset ) { - state = NVDATAMGMT_EXEC_STATE_IDLE; + state = NVM_EXEC_STATE_IDLE; } else { @@ -291,7 +291,7 @@ U32 memoryPtr = jobSpecs.recordFlashAddress + recordAddressOffset; U08* structPtr = jobSpecs.structAddressPtr + recordAddressOffset; - writtenRecordStatus = NVDATAMGMT_RECORD_NOT_CHECKED; + writtenRecordStatus = NVM_RECORD_NOT_CHECKED; // Issue the write command writeSector( (U32*)memoryPtr, structPtr, MAX_EEPROM_WRITE_BUFFER_BYTES ); @@ -302,7 +302,7 @@ else if ( timeoutStatus == TRUE ) { recordAddressOffset = 0; - state = NVDATAMGMT_EXEC_STATE_IDLE; + state = NVM_EXEC_STATE_IDLE; } return state; @@ -316,14 +316,14 @@ * @details Outputs: None * @return next state *************************************************************************/ -static NVDATAMGMT_EXEC_STATE_T handleExecReadFromEEPROMState ( void ) +static NVM_EXEC_STATE_T handleExecReadFromEEPROMState ( void ) { - NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_READ_FROM_EEPROM; + NVM_EXEC_STATE_T state = NVM_EXEC_STATE_READ_FROM_EEPROM; BOOL timeoutStatus = didCommandTimeout( state ); if ( ( TRUE == isFlashReady() ) || ( TRUE == timeoutStatus ) ) { - state = NVDATAMGMT_EXEC_STATE_IDLE; + state = NVM_EXEC_STATE_IDLE; } return state; @@ -339,12 +339,12 @@ * writtenRecordStatus * @return next state of the state machine *************************************************************************/ -static NVDATAMGMT_EXEC_STATE_T handleExecVerifyEEPROMWriteState ( void ) +static NVM_EXEC_STATE_T handleExecVerifyEEPROMWriteState ( void ) { - NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_VERIFY_EEPROM_WRITE; + NVM_EXEC_STATE_T state = NVM_EXEC_STATE_VERIFY_EEPROM_WRITE; BOOL timeoutStatus = didCommandTimeout( state ); PROCESS_RECORD_JOB_T recordCurrentJob = getCurrentProcessRecordJob(); - RECORD_JOBS_STATE_T job = recordCurrentJob.recordJob; + NVM_RECORD_TYPE_T job = recordCurrentJob.recordJob; PROCESS_RECORD_SPECS_T jobSpecs = getProcessRecord ( job ); // Check if the flash is ready @@ -361,9 +361,9 @@ if ( writtenRecordCheckBuffer[ i ] != *bufferPtr ) { // Data is not valid. Schedule an erase and write of the record - writtenRecordStatus = NVDATAMGMT_RECORD_NOT_VALID; + writtenRecordStatus = NVM_RECORD_NOT_VALID; enqueueEraseAndWriteSector( job ); - state = NVDATAMGMT_EXEC_STATE_IDLE; + state = NVM_EXEC_STATE_IDLE; // Exit the loop since there is no point to check the rest of data break; } @@ -372,9 +372,9 @@ // Everything is good increment the pointer to check the next byte. bufferPtr++; // Record data is valid so far - writtenRecordStatus = NVDATAMGMT_RECORD_VALID; + writtenRecordStatus = NVM_RECORD_VALID; // Go back write to EEPROM state to continue writing the record data - state = NVDATAMGMT_EXEC_STATE_WRITE_TO_EEPROM; + state = NVM_EXEC_STATE_WRITE_TO_EEPROM; } } } @@ -384,16 +384,16 @@ /*********************************************************************//** * @brief - * The resetNVDataMgmtPOSTState function resets the NV data management POST + * The resetNVMPOSTState function resets the NV data management POST * state and enqueues all the NV records to be read again from the NV memory. * @details Inputs: none * @details Outputs: nvDataMgmtSelfTestState, nvDataMgmtSelfTestResult * @return none *************************************************************************/ -void resetNVDataMgmtPOSTState( void ) +void resetNVMPOSTState( void ) { updateNVSelfTestResult( SELF_TEST_STATUS_IN_PROGRESS ); - updateNVSelfTestState( NVDATAMGMT_SELF_TEST_STATE_READ_RECORDS ); + updateNVSelfTestState( NVM_SELF_TEST_STATE_READ_RECORDS ); } /*********************************************************************//** @@ -406,7 +406,7 @@ * @param state the state that the command timed out * @return TRUE if a command timed out *************************************************************************/ -static BOOL didCommandTimeout ( NVDATAMGMT_EXEC_STATE_T state ) +static BOOL didCommandTimeout ( NVM_EXEC_STATE_T state ) { BOOL status = FALSE;