Index: NVDataMgmt.c =================================================================== diff -u -rc1cdf8965a4b1b913f939023b1b68fc48b0f06a5 -r37b8ec4f732712aa5b7bb3bfee97d626718476c3 --- NVDataMgmt.c (.../NVDataMgmt.c) (revision c1cdf8965a4b1b913f939023b1b68fc48b0f06a5) +++ NVDataMgmt.c (.../NVDataMgmt.c) (revision 37b8ec4f732712aa5b7bb3bfee97d626718476c3) @@ -15,6 +15,7 @@ **************************************************************************/ // Includes + #include #include "F021.h" @@ -25,52 +26,52 @@ #include "Timers.h" // Private defines -#define QUEUE_MAX_SIZE 10U -#define QUEUE_FRONT_INDEX 0U -#define QUEUE_EMPTY_INDEX -1 -#define ROUNDED_HCLK_FREQ FLOAT_TO_INT_WITH_ROUND(HCLK_FREQ) +#define QUEUE_MAX_SIZE 10U +#define QUEUE_FRONT_INDEX 0U +#define QUEUE_EMPTY_INDEX -1 + +// The clock frequency comes from HCLK_FREQ and it has to be rounded up to the +// nearest number +#define ROUNDED_HCLK_FREQ FLOAT_TO_INT_WITH_ROUND(HCLK_FREQ) #define BANK7_SECTOR_0_31_ENABLE_BIT_MASK 0x0000000F #define BANK7_SECTOR_32_63_ENABLE_BIT_MASK 0x00000000 -#define BANK7_SECTOR0_START_ADDRESS 0xF0200000 -#define BANK7_SECTOR0_END_ADDRESS 0xF0203FFF +#define BANK7_SECTOR0_START_ADDRESS 0xF0200000 +#define BANK7_SECTOR0_END_ADDRESS 0xF0203FFF -#define BANK7_SECTOR1_START_ADDRESS 0xF0204000 -#define BANK7_SECTOR1_END_ADDRESS 0xF0207FFF +#define BANK7_SECTOR1_START_ADDRESS 0xF0204000 +#define BANK7_SECTOR1_END_ADDRESS 0xF0207FFF -#define BANK7_SECTOR2_START_ADDRESS 0xF0208000 -#define BANK7_SECTOR2_END_ADDRESS 0xF020BFFF +#define BANK7_SECTOR2_START_ADDRESS 0xF0208000 +#define BANK7_SECTOR2_END_ADDRESS 0xF020BFFF -#define BANK7_SECTOR3_START_ADDRESS 0xF020C000 -#define BANK7_SECTOR3_END_ADDRESS 0xF020FFFF +#define BANK7_SECTOR3_START_ADDRESS 0xF020C000 +#define BANK7_SECTOR3_END_ADDRESS 0xF020FFFF -#define LOG_DATA_MAX_SIZE_BYTES 32U -#define MAX_NUM_OF_SECTORS_FOR_LOG_DATA 3U -#define MAX_LOG_DATA_PER_SECTOR ( ( BANK7_SECTOR1_END_ADDRESS + 1 ) - \ - BANK7_SECTOR1_START_ADDRESS ) / LOG_DATA_MAX_SIZE_BYTES - +#define LOG_DATA_MAX_SIZE_BYTES 32U +#define LOG_DATA_START_INDEX 1U +#define MAX_NUM_OF_SECTORS_FOR_LOG_DATA 3U +#define MAX_LOG_DATA_PER_SECTOR (((BANK7_SECTOR1_END_ADDRESS + 1) - \ + BANK7_SECTOR1_START_ADDRESS) / LOG_DATA_MAX_SIZE_BYTES) // RTC RAM defines -#define BOOTLOADER_FLAG_START_ADDRESS 0x00000000 -#define BOOTLOADER_FLAG_LENGTH_BYTES 4U +#define BOOTLOADER_FLAG_START_ADDRESS 0x00000000 +#define BOOTLOADER_FLAG_LENGTH_BYTES 4U +#define LOG_RECORD_START_ADDRESS 0x00000014 // 20 +#define MFG_RECORD_START_ADDRESS 0X0000001E // 30 +#define HD_TREATMENT_TIME_START_ADDRESS 0X00000028 // 40 +#define DG_CONSUMED_WATER_START_ADDRESS 0X00000032 // 50 -// Address 20 in the RTC RAM -#define LOG_RECORD_START_ADDRESS 0x00000014 +#define BUFFER_INDEX_0 0U +#define BUFFER_INDEX_1 1U +#define BUFFER_INDEX_2 2U +#define BUFFER_INDEX_3 3U +#define BUFFER_INDEX_4 4U +#define BUFFER_INDEX_5 5U -// Address 30 in the RTC RAM -#define MFG_RECORD_START_ADDRESS 0X0000001E - -#define BUFFER_INDEX_0 0U -#define BUFFER_INDEX_1 1U -#define BUFFER_INDEX_2 2U -#define BUFFER_INDEX_3 3U -#define BUFFER_INDEX_4 4U -#define BUFFER_INDEX_5 5U - -#define MAX_CRC_LENGTH_BYTES 2U +#define MAX_CRC_LENGTH_BYTES 2U #define MAX_EEPROM_WRITE_BUFFER_BYTES 16U - typedef enum NVDataMgmt_Self_Test_States { NVDATAMGMT_SELF_TEST_STATE_START = 0, @@ -123,7 +124,7 @@ typedef struct { - U16 recordsCount; + U16 recordCount; U16 nextWriteIndex; U16 nextReadIndex; } LOG_RECORD_T; @@ -156,28 +157,29 @@ // Private functions -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestStart( void ); -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadMfgRecord( void ); -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadBootloaderFlag( void ); -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadLogRecord( void ); -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestCheckCRC( void ); +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestStart ( void ); +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadMfgRecord ( void ); +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadBootloaderFlag ( void ); +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadLogRecord ( void ); +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestCheckCRC ( void ); -static NVDATAMGMT_EXEC_STATE_T handleExecWaitForPostState( void ); -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 handleExecWriteToRAMState( void ); -static NVDATAMGMT_EXEC_STATE_T handleExecReadFromRAMState( void ); +static NVDATAMGMT_EXEC_STATE_T handleExecWaitForPostState ( void ); +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 handleExecWriteToRAMState ( void ); +static NVDATAMGMT_EXEC_STATE_T handleExecReadFromRAMState ( void ); // Queue functions -static void setMemoryOpsStruct( NVDATAMGMT_OPERATION_STATE_T ops, NVDATAMGMT_LOCATION_STATE_T location, + +static void setMemoryOpsStruct ( NVDATAMGMT_OPERATION_STATE_T ops, NVDATAMGMT_LOCATION_STATE_T location, + U32 startAddress, U08* data, U32 length ); +static void enqueue ( NVDATAMGMT_OPERATION_STATE_T ops, NVDATAMGMT_LOCATION_STATE_T location, U32 startAddress, U08* data, U32 length ); -static void enqueue( NVDATAMGMT_OPERATION_STATE_T ops, NVDATAMGMT_LOCATION_STATE_T location, - U32 startAddress, U08* data, U32 length ); -static void dequeue( void ); -static BOOL isQueueEmpty( void ); -static BOOL isQueueFull( void ); +static void dequeue ( void ); +static BOOL isQueueEmpty ( void ); +static BOOL isQueueFull ( void ); // Private variables @@ -209,7 +211,7 @@ * @param none * @return none *************************************************************************/ -void initNVDataMgmt( void ) +void initNVDataMgmt ( void ) { // TODO: initialize all the necessary variables NVDataMgmtSelfTestState = NVDATAMGMT_SELF_TEST_STATE_START; @@ -232,7 +234,7 @@ * @param none * @return NVDATAMGMT_SELF_TEST_STATE_T *************************************************************************/ -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestStart( void ) +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestStart ( void ) { NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_START; if ( isServiceOnEntry ) @@ -249,27 +251,58 @@ return state; } -BOOL setSerialNumber( char* buffer ) +BOOL setSerialNumber ( char* buffer ) { BOOL status = TRUE; return status; } -BOOL setLogData( U08* data ) +/************************************************************************* + * @brief writeLogData + * The writeLogData checks if the queue is not full and if it is not, it calls + * enqueue to schedule a job for writing the log data + * @details + * Inputs : data + * Outputs : BOOL + * @param none + * @return BOOL + *************************************************************************/ +BOOL writeLogData ( U08* data ) { BOOL status = FALSE; if ( !isQueueFull() ) { - enqueue( NVDATAMGMT_WRITE, NVDATAMGMT_EEPROM, BANK7_SECTOR1_START_ADDRESS, - data, sizeof( LOG_DATA_T ) ); + enqueue ( NVDATAMGMT_WRITE, NVDATAMGMT_EEPROM, 0, data, sizeof( LOG_DATA_T ) ); status = TRUE; } return status; } /************************************************************************* + * @brief readLogData + * The readLogData checks if the queue is not full and if it is not, it calls + * enqueue to schedule a job for writing the log data + * @details + * Inputs : data + * Outputs : BOOL + * @param none + * @return BOOL + *************************************************************************/ +BOOL readLogData ( U08* buffer ) +{ + BOOL status = FALSE; + + if ( !isQueueFull() ) + { + enqueue( NVDATAMGMT_READ, NVDATAMGMT_EEPROM, 0, buffer, sizeof(buffer) ); + status = TRUE; + } + return status; +} + +/************************************************************************* * @brief handleSelfTestReadBootloaderFlag * The handleSelfTestReadBootloaderFlag reads the bootloader flag * from RTC RAM @@ -279,7 +312,7 @@ * @param none * @return NVDATAMGMT_SELF_TEST_STATE_T *************************************************************************/ -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadBootloaderFlag( void ) +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadBootloaderFlag ( void ) { NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_READ_BOOTLOADER_FLAG; if ( isServiceOnEntry && getRTCRAMState() == RTC_RAM_STATE_READY ) @@ -317,18 +350,19 @@ NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_READ_LOG_RECORD; if ( isServiceOnEntry && getRTCRAMState() == RTC_RAM_STATE_READY ) { - readFromRAM( LOG_RECORD_START_ADDRESS, sizeof ( LOG_RECORD_T ) ); + readFromRAM ( LOG_RECORD_START_ADDRESS, sizeof ( LOG_RECORD_T ) ); isServiceOnEntry= FALSE; } if ( getRTCRAMStatus() == RTC_RAM_STATUS_IDLE ) { - getDataFromRAM( readBuffer, sizeof ( LOG_RECORD_T ) ); - logRecord.recordsCount = ( readBuffer [ BUFFER_INDEX_0 ] << SHIFT_8_BITS_FOR_BYTE_SHIFT ) - + readBuffer [ BUFFER_INDEX_1 ]; - logRecord.nextWriteIndex = ( readBuffer [ BUFFER_INDEX_2 ] << SHIFT_8_BITS_FOR_BYTE_SHIFT ) - + readBuffer [ BUFFER_INDEX_3 ]; - logRecord.nextReadIndex = ( readBuffer [ BUFFER_INDEX_4 ] << SHIFT_8_BITS_FOR_BYTE_SHIFT ) - + readBuffer [ BUFFER_INDEX_5 ]; + U08 i; + U08* logPtr = (U08*)&logRecord; + getDataFromRAM ( readBuffer, sizeof ( LOG_RECORD_T ) ); + for ( i = 0; i < sizeof ( LOG_RECORD_T ); i++ ) + { + *logPtr = ( readBuffer[ i ] & MASK_OFF_MSB ); + logPtr++; + } state = NVDATAMGMT_SELF_TEST_STATE_READ_MFG_RECORDS; isServiceOnEntry = TRUE; } @@ -345,14 +379,14 @@ * @param none * @return NVDATAMGMT_SELF_TEST_STATE_T *************************************************************************/ -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadMfgRecord( void ) +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadMfgRecord ( void ) { NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_READ_MFG_RECORDS; if ( isServiceOnEntry ) { U32 length = MAX_SYS_SERIAL_NUMBER_CHARACTERS + MAX_HW_SERIAL_NUMBER_CHARACTERS + MAX_MFG_DATE_CHARACTERS + MAX_CRC_LENGTH_BYTES; - EEPROMStatus = Fapi_doMarginRead( (U32*)BANK7_SECTOR0_START_ADDRESS, (U32*)readBuffer, length, Fapi_NormalRead ); + EEPROMStatus = Fapi_doMarginRead ( (U32*)BANK7_SECTOR0_START_ADDRESS, (U32*)readBuffer, length, Fapi_NormalRead ); isServiceOnEntry = FALSE; } else if ( EEPROMStatus == Fapi_Status_Success ) @@ -372,7 +406,7 @@ } mfgRecord.crc = ( readBuffer [ MAX_SYS_SERIAL_NUMBER_CHARACTERS + MAX_HW_SERIAL_NUMBER_CHARACTERS + MAX_MFG_DATE_CHARACTERS + 1 ] << SHIFT_8_BITS_FOR_BYTE_SHIFT ) + - readBuffer [ MAX_SYS_SERIAL_NUMBER_CHARACTERS + MAX_HW_SERIAL_NUMBER_CHARACTERS + MAX_MFG_DATE_CHARACTERS ]; + readBuffer [ MAX_SYS_SERIAL_NUMBER_CHARACTERS + MAX_HW_SERIAL_NUMBER_CHARACTERS + MAX_MFG_DATE_CHARACTERS ]; state = NVDATAMGMT_SELF_TEST_STATE_CHECK_CRC; isServiceOnEntry = TRUE; } @@ -389,11 +423,11 @@ * @param none * @return NVDATAMGMT_SELF_TEST_STATE_T *************************************************************************/ -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestCheckCRC( void ) +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestCheckCRC ( void ) { NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_COMPLETE; U16 calculatedCRC; - calculatedCRC = crc16( (U08*)&mfgRecord.mfgData, sizeof( MFG_DATA_T ) ); + calculatedCRC = crc16 ( (U08*)&mfgRecord.mfgData, sizeof( MFG_DATA_T ) ); if ( calculatedCRC == mfgRecord.crc ) { @@ -417,7 +451,7 @@ *************************************************************************/ SELF_TEST_STATUS_T execNVDataMgmtSelfTest ( void ) { - switch( NVDataMgmtSelfTestState ) + switch ( NVDataMgmtSelfTestState ) { case NVDATAMGMT_SELF_TEST_STATE_START: @@ -468,7 +502,7 @@ * @param none * @return none *************************************************************************/ -void execNVDataMgmt( void ) +void execNVDataMgmt ( void ) { switch ( NVDataMgmtExecState ) { @@ -520,7 +554,16 @@ } } -static NVDATAMGMT_EXEC_STATE_T handleExecWaitForPostState( void ) +/************************************************************************* + * @brief handleExecWaitForPostState + * The handleExecWaitForPostState waits for POST to be completed + * @details + * Inputs : none + * Outputs : NVDATAMGMT_EXEC_STATE_T + * @param none + * @return NVDATAMGMT_EXEC_STATE_T + *************************************************************************/ +static NVDATAMGMT_EXEC_STATE_T handleExecWaitForPostState ( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_WAIT_FOR_POST; if ( NVDataMgmtSelfTestState == NVDATAMGMT_SELF_TEST_STATE_COMPLETE && @@ -536,15 +579,10 @@ logData.data4 = 80.125; logData.data5 = 68; - setLogData( (U08*)&logData ); + writeLogData( (U08*)&logData ); + readLogData( (U08*)&tempBufferForTest ); - logRecord.recordsCount = 4; - logRecord.nextReadIndex = 3; - logRecord.nextWriteIndex = 6; - - //enqueue(NVDATAMGMT_WRITE, NVDATAMGMT_RTC, LOG_RECORD_START_ADDRESS, (U08*)&logRecord, sizeof(LOG_RECORD_T)); - enqueue(NVDATAMGMT_READ, NVDATAMGMT_RTC, LOG_RECORD_START_ADDRESS, 0, 16); - //enqueue(NVDATAMGMT_WRITE, NVDATAMGMT_EEPROM, BANK7_SECTOR1_START_ADDRESS+0x50, (U08*)&tempBufferForTest, sizeof(tempBufferForTest)); + //enqueue(NVDATAMGMT_READ, NVDATAMGMT_EEPROM, BANK7_SECTOR1_START_ADDRESS, (U08*)&tempBufferForTest, sizeof(tempBufferForTest)); //setSerialNumber( (char*)tempBufferForTest ); // TODO: REMOVE THIS CODE state = NVDATAMGMT_EXEC_STATE_IDLE; @@ -556,7 +594,17 @@ return state; } -static NVDATAMGMT_EXEC_STATE_T handleExecIdleState( void ) +/************************************************************************* + * @brief handleExecIdleState + * The handleExecIdleState checks if the queue is empty and if it is not + * empty, it sets the state of the job + * @details + * Inputs : none + * Outputs : NVDATAMGMT_EXEC_STATE_T + * @param none + * @return NVDATAMGMT_EXEC_STATE_T + *************************************************************************/ +static NVDATAMGMT_EXEC_STATE_T handleExecIdleState ( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_IDLE; if ( !isQueueEmpty() ) @@ -586,7 +634,18 @@ } return state; } -static NVDATAMGMT_EXEC_STATE_T handleExecWriteToEEPROMState( void ) + +/************************************************************************* + * @brief handleExecWriteToEEPROMState + * The handleExecWriteToEEPROMState issues a write command to EEPROM on entry + * and if the write was successful, it sets the state to Idle + * @details + * Inputs : none + * Outputs : NVDATAMGMT_EXEC_STATE_T + * @param none + * @return NVDATAMGMT_EXEC_STATE_T + *************************************************************************/ +static NVDATAMGMT_EXEC_STATE_T handleExecWriteToEEPROMState ( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_WRITE_TO_EEPROM; if ( isServiceOnEntry ) @@ -605,7 +664,18 @@ } return state; } -static NVDATAMGMT_EXEC_STATE_T handleExecReadFromEEPROMState( void ) + +/************************************************************************* + * @brief handleExecReadFromEEPROMState + * The handleExecReadFromEEPROMState issues a read command to EEPROM on entry + * and if the read was successful, it sets the state to Idle + * @details + * Inputs : none + * Outputs : NVDATAMGMT_EXEC_STATE_T + * @param none + * @return NVDATAMGMT_EXEC_STATE_T + *************************************************************************/ +static NVDATAMGMT_EXEC_STATE_T handleExecReadFromEEPROMState ( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_READ_FROM_EEPROM; if ( isServiceOnEntry ) @@ -624,12 +694,22 @@ return state; } -static NVDATAMGMT_EXEC_STATE_T handleExecEraseState( void ) +/************************************************************************* + * @brief handleExecEraseState + * The handleExecEraseState issues an erase command to EEPROM on entry + * and if the erase was successful, it sets the state to Idle + * @details + * Inputs : none + * Outputs : NVDATAMGMT_EXEC_STATE_T + * @param none + * @return NVDATAMGMT_EXEC_STATE_T + *************************************************************************/ +static NVDATAMGMT_EXEC_STATE_T handleExecEraseState ( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_ERASE; if ( isServiceOnEntry ) { - EEPROMStatus = Fapi_issueAsyncCommandWithAddress( Fapi_EraseSector, jobQueue [ queueFrontIndex ].startAddress ); + EEPROMStatus = Fapi_issueAsyncCommandWithAddress ( Fapi_EraseSector, jobQueue [ queueFrontIndex ].startAddress ); isServiceOnEntry = FALSE; } else if ( FAPI_CHECK_FSM_READY_BUSY == Fapi_Status_FsmReady ) @@ -641,12 +721,23 @@ return state; } -static NVDATAMGMT_EXEC_STATE_T handleExecWriteToRAMState( void ) +/************************************************************************* + * @brief handleExecWriteToRAMState + * The handleExecWriteToRAMState issues a write command to RTC RAM if the + * RAM was ready, and if the RAM got back to Idle after the write command, + * it sets the state to Idle + * @details + * Inputs : none + * Outputs : NVDATAMGMT_EXEC_STATE_T + * @param none + * @return NVDATAMGMT_EXEC_STATE_T + *************************************************************************/ +static NVDATAMGMT_EXEC_STATE_T handleExecWriteToRAMState ( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_WRITE_TO_RTC; if ( isServiceOnEntry && getRTCRAMState() == RTC_RAM_STATE_READY ) { - writeToRAM( (U32)( jobQueue [ queueFrontIndex ].startAddress ), + writeToRAM ( (U32)( jobQueue [ queueFrontIndex ].startAddress ), jobQueue [ queueFrontIndex ].buffer, jobQueue [ queueFrontIndex ].length ); isServiceOnEntry= FALSE; @@ -660,7 +751,19 @@ return state; } -static NVDATAMGMT_EXEC_STATE_T handleExecReadFromRAMState( void ) +/************************************************************************* + * @brief handleExecReadFromRAMState + * The handleExecReadFromRAMState issues a read command to RTC RAM if the + * RAM was ready, and if the RAM got back to Idle after the read command, + * it calls another function to read the data back from RTC RAM and + * it sets the state to Idle + * @details + * Inputs : none + * Outputs : NVDATAMGMT_EXEC_STATE_T + * @param none + * @return NVDATAMGMT_EXEC_STATE_T + *************************************************************************/ +static NVDATAMGMT_EXEC_STATE_T handleExecReadFromRAMState ( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_READ_FROM_RTC; if ( isServiceOnEntry && getRTCRAMState() == RTC_RAM_STATE_READY ) @@ -680,6 +783,15 @@ return state; } +/************************************************************************* + * @brief setMemoryOpsStruct + * The setMemoryOpsStruct fills up the job struct + * @details + * Inputs : none + * Outputs : none + * @param none + * @return none + *************************************************************************/ static void setMemoryOpsStruct ( NVDATAMGMT_OPERATION_STATE_T ops, NVDATAMGMT_LOCATION_STATE_T location, U32 startAddress, U08* data, U32 length ) { @@ -691,75 +803,136 @@ memcpy ( jobQueue [ queueRearIndex ].buffer, data, length ); } +/************************************************************************* + * @brief enqueue + * The enqueue prepares the jobs to be processed. It checks if the requested + * job is read or write, or if it is RTC or EEPROM and sets the job struct. + * It checks for the corner cases, for instance, if the next write log to EEPROM + * is at the beginning of the next sector, it schedules and erase first and then + * it schedules the write jobs. The function breaks the write to EEPROM jobs to + * 16 bytes at the time + * @details + * Inputs : none + * Outputs : none + * @param none + * @return none + *************************************************************************/ static void enqueue ( NVDATAMGMT_OPERATION_STATE_T ops, NVDATAMGMT_LOCATION_STATE_T location, U32 startAddress, U08* data, U32 length ) { U32 quotient = 0; U32 modulus = 0; U32 maxBufferLength = 0; + U32 opsStartAddress = startAddress; U08 i; - if ( ops == NVDATAMGMT_WRITE && location == NVDATAMGMT_EEPROM ) + // Setup EEPROM write + if ( ops == NVDATAMGMT_WRITE && location == NVDATAMGMT_EEPROM && startAddress == 0 ) { + maxBufferLength = MAX_EEPROM_WRITE_BUFFER_BYTES; + // The write address is calculated using the next write index and is and offset from + // the start of sector 1. Sectors 1,2, and 3 have been allocated for logging data + opsStartAddress = ( logRecord.nextWriteIndex * LOG_DATA_MAX_SIZE_BYTES ) + BANK7_SECTOR1_START_ADDRESS; + modulus = logRecord.nextWriteIndex % MAX_LOG_DATA_PER_SECTOR; + if ( modulus == 0 ) + { + if ( logRecord.nextWriteIndex == MAX_LOG_DATA_PER_SECTOR * MAX_NUM_OF_SECTORS_FOR_LOG_DATA ) + { + opsStartAddress = BANK7_SECTOR1_START_ADDRESS; + // It is at the end of sector 3, it needs to start over + logRecord.nextWriteIndex = LOG_DATA_START_INDEX; + // Sector 1 is being erased and the maximum number of logs that can be + // stored in it is erased (in this case 512) + logRecord.recordCount = logRecord.recordCount - MAX_LOG_DATA_PER_SECTOR; + } + else + { + if ( logRecord.nextWriteIndex == MAX_LOG_DATA_PER_SECTOR ) + { + opsStartAddress = BANK7_SECTOR2_START_ADDRESS; + } + else if ( logRecord.nextWriteIndex == ( MAX_NUM_OF_SECTORS_FOR_LOG_DATA - 1 ) * MAX_LOG_DATA_PER_SECTOR ) + { + opsStartAddress = BANK7_SECTOR3_START_ADDRESS; + } + logRecord.nextWriteIndex++; + if ( logRecord.recordCount > MAX_NUM_OF_SECTORS_FOR_LOG_DATA ) + { + logRecord.recordCount = logRecord.recordCount - MAX_NUM_OF_SECTORS_FOR_LOG_DATA; + } + else + { + logRecord.recordCount++; + logRecord.nextWriteIndex++; + } + } + // Erase does not need payload or length + setMemoryOpsStruct ( NVDATAMGMT_ERASE, NVDATAMGMT_EEPROM, opsStartAddress, 0, 0 ); + } + else + { + logRecord.recordCount++; + logRecord.nextWriteIndex++; + } + // Update the log record + setMemoryOpsStruct ( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, LOG_RECORD_START_ADDRESS, + (U08*)&logRecord, sizeof( LOG_RECORD_T ) ); } - // If the start address is at the beginning of any of the sectors and the ops is write to - // EEPROM, first erase the sector - if ( ( startAddress == BANK7_SECTOR0_START_ADDRESS || startAddress == BANK7_SECTOR1_START_ADDRESS || - startAddress == BANK7_SECTOR2_START_ADDRESS || startAddress == BANK7_SECTOR3_START_ADDRESS ) && - ops == NVDATAMGMT_WRITE ) + // Setup EEPROM read + else if ( ops == NVDATAMGMT_READ && location == NVDATAMGMT_EEPROM && startAddress == 0 ) { - setMemoryOpsStruct( NVDATAMGMT_ERASE, NVDATAMGMT_EEPROM, startAddress, 0, LOG_DATA_MAX_SIZE_BYTES ); - } - - if ( ops == NVDATAMGMT_WRITE && location == NVDATAMGMT_EEPROM ) - { - maxBufferLength = MAX_EEPROM_WRITE_BUFFER_BYTES; - } - else - { maxBufferLength = LOG_DATA_MAX_SIZE_BYTES; + // The write address is calculated using the next write index and is and offset from + // the start of sector 1. Sectors 1,2, and 3 have been allocated for logging data + opsStartAddress = ( logRecord.nextReadIndex * LOG_DATA_MAX_SIZE_BYTES ) + BANK7_SECTOR1_START_ADDRESS; + if ( logRecord.nextReadIndex == MAX_LOG_DATA_PER_SECTOR * MAX_NUM_OF_SECTORS_FOR_LOG_DATA ) + { + logRecord.nextReadIndex = LOG_DATA_START_INDEX; + } + else + { + logRecord.nextReadIndex++; + } + // Update the log record + setMemoryOpsStruct ( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, LOG_RECORD_START_ADDRESS, + (U08*)&logRecord, sizeof( LOG_RECORD_T ) ); } if ( length > maxBufferLength ) { quotient = length / maxBufferLength; modulus = length % maxBufferLength; for ( i = 0; i < quotient; i++ ) { - setMemoryOpsStruct( ops, location, ( startAddress + ( i * maxBufferLength ) ), + setMemoryOpsStruct ( ops, location, ( opsStartAddress + ( i * maxBufferLength ) ), data + ( i * maxBufferLength ), maxBufferLength ); } if ( modulus != 0 ) { - setMemoryOpsStruct( ops, location, ( startAddress + ( quotient * maxBufferLength ) ), + setMemoryOpsStruct ( ops, location, ( opsStartAddress + ( quotient * maxBufferLength ) ), data + ( quotient * maxBufferLength ), modulus ); } } else { - setMemoryOpsStruct( ops, location, startAddress, data, length ); + setMemoryOpsStruct ( ops, location, opsStartAddress, data, length ); } - if ( ops == NVDATAMGMT_WRITE && location == NVDATAMGMT_EEPROM ) - { - // setup the RAM log for write (counter and write address) - logRecord.recordsCount++; - logRecord.nextWriteIndex++; - setMemoryOpsStruct( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, LOG_RECORD_START_ADDRESS, - (U08*)&logRecord, sizeof( LOG_RECORD_T ) ); - } - else if ( ops == NVDATAMGMT_READ && location == NVDATAMGMT_EEPROM ) - { - // setup the RAM log for read (read address) - logRecord.nextReadIndex++; - setMemoryOpsStruct( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, LOG_RECORD_START_ADDRESS, - (U08*)&logRecord, sizeof( LOG_RECORD_T ) ); - } if ( queueFrontIndex == QUEUE_EMPTY_INDEX ) { queueFrontIndex++; } } -static void dequeue( void ) +/************************************************************************* + * @brief dequeue + * The dequeue increments the front index counter and if it is equal to + * rear index, it sets it to -1, meaning that the queue is empty + * @details + * Inputs : none + * Outputs : none + * @param none + * @return none + *************************************************************************/ +static void dequeue ( void ) { if ( queueFrontIndex < queueRearIndex ) { @@ -770,6 +943,17 @@ queueFrontIndex = queueRearIndex = QUEUE_EMPTY_INDEX; } } + +/************************************************************************* + * @brief isQueueEmpty + * The isQueueEmpty checks whether the queue is empty and if it is empty, + * it will return a false + * @details + * Inputs : none + * Outputs : BOOL + * @param none + * @return BOOL + *************************************************************************/ static BOOL isQueueEmpty ( void ) { BOOL isEmpty = TRUE; @@ -779,7 +963,18 @@ } return isEmpty; } -static BOOL isQueueFull( void ) + +/************************************************************************* + * @brief isQueueFull + * The isQueueFull checks whether the queue is full and if it is full, + * it will return a true + * @details + * Inputs : none + * Outputs : BOOL + * @param none + * @return BOOL + *************************************************************************/ +static BOOL isQueueFull ( void ) { BOOL isFull = FALSE; if ( queueRearIndex == QUEUE_MAX_SIZE - 1 )