Index: NVDataMgmt.c =================================================================== diff -u -rd3cde5e8996177f4fef18929fe9595ae623ef3c5 -rc1cdf8965a4b1b913f939023b1b68fc48b0f06a5 --- NVDataMgmt.c (.../NVDataMgmt.c) (revision d3cde5e8996177f4fef18929fe9595ae623ef3c5) +++ NVDataMgmt.c (.../NVDataMgmt.c) (revision c1cdf8965a4b1b913f939023b1b68fc48b0f06a5) @@ -29,8 +29,6 @@ #define QUEUE_FRONT_INDEX 0U #define QUEUE_EMPTY_INDEX -1 -#define MEMORY_OPS_BUFFER_LENGTH 32U - #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 @@ -44,34 +42,35 @@ #define BANK7_SECTOR2_START_ADDRESS 0xF0208000 #define BANK7_SECTOR2_END_ADDRESS 0xF020BFFF -#define BANK7_SECTOR3_START_ADDRESS 0xF020FFFF -#define BANK7_SECTOR3_END_ADDRESS 0xF020C000 +#define BANK7_SECTOR3_START_ADDRESS 0xF020C000 +#define BANK7_SECTOR3_END_ADDRESS 0xF020FFFF -// RTC RAM defines +#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 BOOTLOADER_FLAG_START_ADDRESS 0x0000 +// RTC RAM defines +#define BOOTLOADER_FLAG_START_ADDRESS 0x00000000 #define BOOTLOADER_FLAG_LENGTH_BYTES 4U // Address 20 in the RTC RAM -#define LOG_RECORDS_START_ADDRESS 0x0014 -#define LOG_RECORDS_LENGTH_BYTES 6U +#define LOG_RECORD_START_ADDRESS 0x00000014 +// 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_SYS_SERIAL_NUMBER_CHARACTERS 7U -#define MAX_HW_SERIAL_NUMBER_CHARACTERS 5U -#define MAX_MFG_DATE_CHARACTERS 10U #define MAX_CRC_LENGTH_BYTES 2U #define MAX_EEPROM_WRITE_BUFFER_BYTES 16U -//#define IDLE_TIME 10U // ms - typedef enum NVDataMgmt_Self_Test_States { NVDATAMGMT_SELF_TEST_STATE_START = 0, @@ -118,7 +117,7 @@ NVDATAMGMT_OPERATION_STATE_T memoryOperation; NVDATAMGMT_LOCATION_STATE_T memoryLocation; U32* startAddress; - U08 buffer [ MEMORY_OPS_BUFFER_LENGTH ]; + U08 buffer [ LOG_DATA_MAX_SIZE_BYTES ]; U32 length; }; @@ -165,23 +164,25 @@ static NVDATAMGMT_EXEC_STATE_T handleExecWaitForPostState( void ); static NVDATAMGMT_EXEC_STATE_T handleExecIdleState( void ); -static NVDATAMGMT_EXEC_STATE_T handleExecWriteState( void ); static NVDATAMGMT_EXEC_STATE_T handleExecEraseState( void ); -static NVDATAMGMT_EXEC_STATE_T handleExecReadState( 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, - U32 startAddress, U08* data, U32 length); +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 dequeue( void ); -static BOOL isQueueEmpty ( void ); -static U08 getQueueSize( void ); +static BOOL isQueueEmpty( void ); +static BOOL isQueueFull( void ); // Private variables struct MEMORY_OPS_T jobQueue [ QUEUE_MAX_SIZE ]; -static U08 readBuffer [ MEMORY_OPS_BUFFER_LENGTH ]; +static U08 readBuffer [ LOG_DATA_MAX_SIZE_BYTES ]; static LOG_RECORD_T logRecord; static LOG_DATA_T logData; static MFG_RECORD_T mfgRecord; @@ -195,7 +196,7 @@ static U32 bootloaderFlag = 0; // REMOVE THIS CODE -//static U08 tempBufferForTest[5] = {'5', 'Y', 'I', 'D', 'P'}; +static U08 tempBufferForTest[5] = {'5', 'Y', 'I', 'D', 'P'}; //static U08 readBufferForTest [ 8 ]; // REMOVE THIS CODE @@ -248,6 +249,26 @@ return state; } +BOOL setSerialNumber( char* buffer ) +{ + BOOL status = TRUE; + + return status; +} + +BOOL setLogData( U08* data ) +{ + BOOL status = FALSE; + + if ( !isQueueFull() ) + { + enqueue( NVDATAMGMT_WRITE, NVDATAMGMT_EEPROM, BANK7_SECTOR1_START_ADDRESS, + data, sizeof( LOG_DATA_T ) ); + status = TRUE; + } + return status; +} + /************************************************************************* * @brief handleSelfTestReadBootloaderFlag * The handleSelfTestReadBootloaderFlag reads the bootloader flag @@ -296,12 +317,12 @@ NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_READ_LOG_RECORD; if ( isServiceOnEntry && getRTCRAMState() == RTC_RAM_STATE_READY ) { - readFromRAM( LOG_RECORDS_START_ADDRESS, LOG_RECORDS_LENGTH_BYTES ); + readFromRAM( LOG_RECORD_START_ADDRESS, sizeof ( LOG_RECORD_T ) ); isServiceOnEntry= FALSE; } if ( getRTCRAMStatus() == RTC_RAM_STATUS_IDLE ) { - getDataFromRAM( readBuffer, LOG_RECORDS_LENGTH_BYTES ); + 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 ) @@ -463,19 +484,29 @@ case NVDATAMGMT_EXEC_STATE_WRITE_TO_EEPROM: - NVDataMgmtExecState = handleExecWriteState(); + NVDataMgmtExecState = handleExecWriteToEEPROMState(); break; + case NVDATAMGMT_EXEC_STATE_READ_FROM_EEPROM: + + NVDataMgmtExecState = handleExecReadFromEEPROMState(); + break; + case NVDATAMGMT_EXEC_STATE_ERASE: NVDataMgmtExecState = handleExecEraseState(); break; - case NVDATAMGMT_EXEC_STATE_READ_FROM_EEPROM: + case NVDATAMGMT_EXEC_STATE_WRITE_TO_RTC: - NVDataMgmtExecState = handleExecReadState(); + NVDataMgmtExecState = handleExecWriteToRAMState(); break; + case NVDATAMGMT_EXEC_STATE_READ_FROM_RTC: + + NVDataMgmtExecState = handleExecReadFromRAMState(); + break; + case NVDATAMGMT_EXEC_STATE_FAULT: // Something failed set the alarms @@ -504,16 +535,22 @@ logData.data3 = 223.58; logData.data4 = 80.125; logData.data5 = 68; - enqueue(NVDATAMGMT_WRITE, NVDATAMGMT_EEPROM, BANK7_SECTOR1_START_ADDRESS, (U08*)&logData, sizeof(LOG_DATA_T)); - //enqueue(NVDATAMGMT_READ, NVDATAMGMT_EEPROM, BANK7_SECTOR1_START_ADDRESS, 0, 8); - enqueue(NVDATAMGMT_WRITE, NVDATAMGMT_EEPROM, BANK7_SECTOR1_START_ADDRESS+0x50, (U08*)&logData, sizeof(LOG_DATA_T)); + + setLogData( (U08*)&logData ); + + 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)); + //setSerialNumber( (char*)tempBufferForTest ); // TODO: REMOVE THIS CODE state = NVDATAMGMT_EXEC_STATE_IDLE; } else if ( NVDataMgmtSelfTestState == NVDATAMGMT_SELF_TEST_STATE_COMPLETE ) { - // TODO: Check this state, do we have to go to FAULT if POST failed? - //state = NVDATAMGMT_EXEC_STATE_FAULT; state = NVDATAMGMT_EXEC_STATE_IDLE; } return state; @@ -549,12 +586,11 @@ } return state; } -static NVDATAMGMT_EXEC_STATE_T handleExecWriteState( void ) +static NVDATAMGMT_EXEC_STATE_T handleExecWriteToEEPROMState( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_WRITE_TO_EEPROM; if ( isServiceOnEntry ) { - // TODO: Convert the buffer to U08* EEPROMStatus = Fapi_issueProgrammingCommand ( jobQueue [ queueFrontIndex ].startAddress, jobQueue [ queueFrontIndex ].buffer, jobQueue [ queueFrontIndex ].length, @@ -569,7 +605,7 @@ } return state; } -static NVDATAMGMT_EXEC_STATE_T handleExecReadState( void ) +static NVDATAMGMT_EXEC_STATE_T handleExecReadFromEEPROMState( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_READ_FROM_EEPROM; if ( isServiceOnEntry ) @@ -605,6 +641,45 @@ return state; } +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 ), + jobQueue [ queueFrontIndex ].buffer, + jobQueue [ queueFrontIndex ].length ); + isServiceOnEntry= FALSE; + } + if ( getRTCRAMStatus() == RTC_RAM_STATUS_IDLE ) + { + state = NVDATAMGMT_EXEC_STATE_IDLE; + dequeue(); + isServiceOnEntry = TRUE; + } + return state; +} + +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 ) + { + readFromRAM( (U32)( jobQueue [ queueFrontIndex ].startAddress ), + jobQueue [ queueFrontIndex ].length ); + isServiceOnEntry= FALSE; + } + if ( getRTCRAMStatus() == RTC_RAM_STATUS_IDLE ) + { + getDataFromRAM( jobQueue [ queueFrontIndex ].buffer, + jobQueue [ queueFrontIndex ].length ); + state = NVDATAMGMT_EXEC_STATE_IDLE; + dequeue(); + isServiceOnEntry = TRUE; + } + return state; +} + static void setMemoryOpsStruct ( NVDATAMGMT_OPERATION_STATE_T ops, NVDATAMGMT_LOCATION_STATE_T location, U32 startAddress, U08* data, U32 length ) { @@ -617,55 +692,67 @@ } static void enqueue ( NVDATAMGMT_OPERATION_STATE_T ops, NVDATAMGMT_LOCATION_STATE_T location, - U32 startAddress, U08* data, U32 length ) + U32 startAddress, U08* data, U32 length ) { U32 quotient = 0; U32 modulus = 0; + U32 maxBufferLength = 0; U08 i; + if ( ops == NVDATAMGMT_WRITE && location == NVDATAMGMT_EEPROM ) + { + + } // 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 ) { - setMemoryOpsStruct( NVDATAMGMT_ERASE, NVDATAMGMT_EEPROM, startAddress, 0, MEMORY_OPS_BUFFER_LENGTH ); + setMemoryOpsStruct( NVDATAMGMT_ERASE, NVDATAMGMT_EEPROM, startAddress, 0, LOG_DATA_MAX_SIZE_BYTES ); } - if ( length > MAX_EEPROM_WRITE_BUFFER_BYTES && ops == NVDATAMGMT_WRITE ) + + if ( ops == NVDATAMGMT_WRITE && location == NVDATAMGMT_EEPROM ) { - quotient = length / MAX_EEPROM_WRITE_BUFFER_BYTES; - modulus = length % MAX_EEPROM_WRITE_BUFFER_BYTES; + maxBufferLength = MAX_EEPROM_WRITE_BUFFER_BYTES; + } + else + { + maxBufferLength = LOG_DATA_MAX_SIZE_BYTES; + } + if ( length > maxBufferLength ) + { + quotient = length / maxBufferLength; + modulus = length % maxBufferLength; for ( i = 0; i < quotient; i++ ) { - setMemoryOpsStruct( ops, location, ( startAddress + ( i * MAX_EEPROM_WRITE_BUFFER_BYTES ) ), - data + ( i * MAX_EEPROM_WRITE_BUFFER_BYTES ), MAX_EEPROM_WRITE_BUFFER_BYTES ); - /*queueRearIndex++; - jobQueue [ queueRearIndex ].memoryOperation = ops; - jobQueue [ queueRearIndex ].memoryLocation = location; - jobQueue [ queueRearIndex ].startAddress = (U32*)( startAddress + ( i * MAX_EEPROM_WRITE_BUFFER_BYTES )); - jobQueue [ queueRearIndex ].length = MAX_EEPROM_WRITE_BUFFER_BYTES; - memcpy ( jobQueue [ queueRearIndex ].buffer, data + ( i * MAX_EEPROM_WRITE_BUFFER_BYTES ), MAX_EEPROM_WRITE_BUFFER_BYTES );*/ + setMemoryOpsStruct( ops, location, ( startAddress + ( i * maxBufferLength ) ), + data + ( i * maxBufferLength ), maxBufferLength ); } if ( modulus != 0 ) { - setMemoryOpsStruct( ops, location, ( startAddress + ( quotient * MAX_EEPROM_WRITE_BUFFER_BYTES ), - data + ( quotient * MAX_EEPROM_WRITE_BUFFER_BYTES ), modulus ); - /*queueRearIndex++; - jobQueue [ queueRearIndex ].memoryOperation = ops; - jobQueue [ queueRearIndex ].memoryLocation = location; - jobQueue [ queueRearIndex ].startAddress = (U32*)( startAddress + ( quotient * MAX_EEPROM_WRITE_BUFFER_BYTES )); - jobQueue [ queueRearIndex ].length = modulus; - memcpy ( jobQueue [ queueRearIndex ].buffer, data + ( quotient * MAX_EEPROM_WRITE_BUFFER_BYTES ), modulus );*/ + setMemoryOpsStruct( ops, location, ( startAddress + ( quotient * maxBufferLength ) ), + data + ( quotient * maxBufferLength ), modulus ); } } else { - queueRearIndex++; - jobQueue [ queueRearIndex ].memoryOperation = ops; - jobQueue [ queueRearIndex ].memoryLocation = location; - jobQueue [ queueRearIndex ].startAddress = (U32*)startAddress; - jobQueue [ queueRearIndex ].length = length; - memcpy ( jobQueue [ queueRearIndex ].buffer, data, length ); + setMemoryOpsStruct( ops, location, startAddress, 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++; @@ -678,6 +765,10 @@ { queueFrontIndex++; } + else if ( queueFrontIndex == queueRearIndex ) + { + queueFrontIndex = queueRearIndex = QUEUE_EMPTY_INDEX; + } } static BOOL isQueueEmpty ( void ) { @@ -688,9 +779,14 @@ } return isEmpty; } -static U08 getQueueSize( void ) +static BOOL isQueueFull( void ) { - return queueRearIndex; + BOOL isFull = FALSE; + if ( queueRearIndex == QUEUE_MAX_SIZE - 1 ) + { + isFull = TRUE; + } + return isFull; }