Index: NVDataMgmt.c =================================================================== diff -u -r37b8ec4f732712aa5b7bb3bfee97d626718476c3 -rf45e0c61d9ca26a63c30cbba80cc5e835a89416a --- NVDataMgmt.c (.../NVDataMgmt.c) (revision 37b8ec4f732712aa5b7bb3bfee97d626718476c3) +++ NVDataMgmt.c (.../NVDataMgmt.c) (revision f45e0c61d9ca26a63c30cbba80cc5e835a89416a) @@ -28,8 +28,7 @@ // Private defines #define QUEUE_MAX_SIZE 10U -#define QUEUE_FRONT_INDEX 0U -#define QUEUE_EMPTY_INDEX -1 +#define QUEUE_START_INDEX 0U // The clock frequency comes from HCLK_FREQ and it has to be rounded up to the // nearest number @@ -53,15 +52,14 @@ #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) + 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 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 - +#define LOG_RECORD_START_ADDRESS 0x00000010 // 16 +#define MFG_RECORD_START_ADDRESS 0X00000020 // 32 +#define HD_TREATMENT_TIME_START_ADDRESS 0X00000030 // 48 +#define DG_CONSUMED_WATER_START_ADDRESS 0X00000040 // 64 #define BUFFER_INDEX_0 0U #define BUFFER_INDEX_1 1U #define BUFFER_INDEX_2 2U @@ -70,7 +68,7 @@ #define BUFFER_INDEX_5 5U #define MAX_CRC_LENGTH_BYTES 2U -#define MAX_EEPROM_WRITE_BUFFER_BYTES 16U +#define MAX_EEPROM_WRITE_BUFFER_BYTES 16U //Assert typedef enum NVDataMgmt_Self_Test_States { @@ -89,7 +87,7 @@ NVDATAMGMT_EXEC_STATE_IDLE, NVDATAMGMT_EXEC_STATE_WRITE_TO_EEPROM, NVDATAMGMT_EXEC_STATE_READ_FROM_EEPROM, - NVDATAMGMT_EXEC_STATE_ERASE, + NVDATAMGMT_EXEC_STATE_ERASE_EEPROM, NVDATAMGMT_EXEC_STATE_WRITE_TO_RTC, NVDATAMGMT_EXEC_STATE_READ_FROM_RTC, NVDATAMGMT_EXEC_STATE_FAULT, @@ -112,7 +110,7 @@ NUM_OF_NVDATAMGMT_LOC_STATES } NVDATAMGMT_LOCATION_STATE_T; -#pragma pack(push,1) +#pragma pack(push, 1) struct MEMORY_OPS_T { NVDATAMGMT_OPERATION_STATE_T memoryOperation; @@ -176,8 +174,10 @@ 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 ); + U32 startAddress, U08* data, U32 length ); static void dequeue ( void ); +static U32 prepareWriteLogJobAndGetStartAddress ( U08* data ); +static U32 prepareReadLogJobAndGetStartAddress (); static BOOL isQueueEmpty ( void ); static BOOL isQueueFull ( void ); @@ -188,8 +188,9 @@ static LOG_RECORD_T logRecord; static LOG_DATA_T logData; static MFG_RECORD_T mfgRecord; -static S16 queueRearIndex = QUEUE_EMPTY_INDEX; -static S16 queueFrontIndex = QUEUE_EMPTY_INDEX; +static U08 queueRearIndex = QUEUE_START_INDEX; +static U08 queueFrontIndex = QUEUE_START_INDEX; +static U08 queueCount = 0; static Fapi_StatusType EEPROMStatus = Fapi_Status_Success; static NVDATAMGMT_SELF_TEST_STATE_T NVDataMgmtSelfTestState = NVDATAMGMT_SELF_TEST_STATE_START; static NVDATAMGMT_EXEC_STATE_T NVDataMgmtExecState = NVDATAMGMT_EXEC_STATE_WAIT_FOR_POST; @@ -219,8 +220,8 @@ NVDataMgmtExecState = NVDATAMGMT_EXEC_STATE_WAIT_FOR_POST; NVDataMgmtSelfTestResult = SELF_TEST_STATUS_IN_PROGRESS; isServiceOnEntry = TRUE; - queueRearIndex = QUEUE_EMPTY_INDEX; - queueFrontIndex = QUEUE_EMPTY_INDEX; + queueRearIndex = QUEUE_START_INDEX; + queueFrontIndex = QUEUE_START_INDEX; EEPROMStatus = Fapi_initializeFlashBanks( ROUNDED_HCLK_FREQ ); EEPROMStatus = Fapi_setActiveFlashBank( Fapi_FlashBank7 ); } @@ -384,12 +385,11 @@ 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, + sizeof( MFG_DATA_T ), Fapi_NormalRead ); isServiceOnEntry = FALSE; } - else if ( EEPROMStatus == Fapi_Status_Success ) + else if ( FAPI_CHECK_FSM_READY_BUSY == Fapi_Status_FsmReady ) { U08 i; for ( i = 0; i < MAX_SYS_SERIAL_NUMBER_CHARACTERS; i++ ) @@ -426,9 +426,7 @@ 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 ) ); - + U16 calculatedCRC = crc16 ( (U08*)&mfgRecord.mfgData, sizeof( MFG_DATA_T ) ); if ( calculatedCRC == mfgRecord.crc ) { NVDataMgmtSelfTestResult = SELF_TEST_STATUS_PASSED; @@ -526,7 +524,7 @@ NVDataMgmtExecState = handleExecReadFromEEPROMState(); break; - case NVDATAMGMT_EXEC_STATE_ERASE: + case NVDATAMGMT_EXEC_STATE_ERASE_EEPROM: NVDataMgmtExecState = handleExecEraseState(); break; @@ -579,10 +577,9 @@ logData.data4 = 80.125; logData.data5 = 68; - writeLogData( (U08*)&logData ); - readLogData( (U08*)&tempBufferForTest ); + writeLogData ( (U08*)&logData ); + readLogData ( (U08*)&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; @@ -621,7 +618,7 @@ } else if ( ops == NVDATAMGMT_ERASE ) { - state = NVDATAMGMT_EXEC_STATE_ERASE; + state = NVDATAMGMT_EXEC_STATE_ERASE_EEPROM; } else if ( ops == NVDATAMGMT_WRITE && location == NVDATAMGMT_RTC ) { @@ -706,7 +703,7 @@ *************************************************************************/ static NVDATAMGMT_EXEC_STATE_T handleExecEraseState ( void ) { - NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_ERASE; + NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_ERASE_EEPROM; if ( isServiceOnEntry ) { EEPROMStatus = Fapi_issueAsyncCommandWithAddress ( Fapi_EraseSector, jobQueue [ queueFrontIndex ].startAddress ); @@ -795,14 +792,106 @@ static void setMemoryOpsStruct ( NVDATAMGMT_OPERATION_STATE_T ops, NVDATAMGMT_LOCATION_STATE_T location, U32 startAddress, U08* data, U32 length ) { - queueRearIndex++; jobQueue [ queueRearIndex ].memoryOperation = ops; jobQueue [ queueRearIndex ].memoryLocation = location; jobQueue [ queueRearIndex ].startAddress = (U32*)startAddress; jobQueue [ queueRearIndex ].length = length; memcpy ( jobQueue [ queueRearIndex ].buffer, data, length ); + queueRearIndex++; + // check the wrap } +static U32 prepareWriteLogJobAndGetStartAddress ( U08* data ) +{ + U32 modulus = 0; + U32 opsStartAddress = 0; + U16 readIndex = 0; + // 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 ) + { + readIndex = logRecord.nextReadIndex; + // define + 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; + // If the read index is somewhere in sector 1, then it will be set to 0 + if ( readIndex > ( MAX_NUM_OF_SECTORS_FOR_LOG_DATA - 1 ) * MAX_LOG_DATA_PER_SECTOR && + readIndex < MAX_LOG_DATA_PER_SECTOR * MAX_NUM_OF_SECTORS_FOR_LOG_DATA ) + { + logRecord.nextReadIndex = 0; // sector 2, + } + } + else + { + if ( logRecord.nextWriteIndex == MAX_LOG_DATA_PER_SECTOR ) + { + opsStartAddress = BANK7_SECTOR2_START_ADDRESS; + if ( readIndex > 0 && readIndex < MAX_LOG_DATA_PER_SECTOR ) + { + logRecord.nextReadIndex = MAX_LOG_DATA_PER_SECTOR + 1; + } + } + else if ( logRecord.nextWriteIndex == ( MAX_NUM_OF_SECTORS_FOR_LOG_DATA - 1 ) * MAX_LOG_DATA_PER_SECTOR ) + { + opsStartAddress = BANK7_SECTOR3_START_ADDRESS; + if ( readIndex > ( MAX_NUM_OF_SECTORS_FOR_LOG_DATA - 1 ) * MAX_LOG_DATA_PER_SECTOR && + readIndex < MAX_LOG_DATA_PER_SECTOR ) + { + logRecord.nextReadIndex = 0; + } + } + 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 ) ); + return opsStartAddress; +} + +static U32 prepareReadLogJobAndGetStartAddress() +{ + // 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 + U32 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 ) ); + + return opsStartAddress; +} + /************************************************************************* * @brief enqueue * The enqueue prepares the jobs to be processed. It checks if the requested @@ -825,101 +914,48 @@ U32 maxBufferLength = 0; U32 opsStartAddress = startAddress; U08 i; - // Setup EEPROM write + // Remove + if ( !isQueueFull() ) + { + queueRearIndex = QUEUE_START_INDEX; + } + // Setup EEPROM write log event 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 ) ); - + opsStartAddress = prepareWriteLogJobAndGetStartAddress ( data ); } - // Setup EEPROM read + // Setup EEPROM read log event else if ( ops == NVDATAMGMT_READ && location == NVDATAMGMT_EEPROM && startAddress == 0 ) { 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 ) ); + opsStartAddress = prepareReadLogJobAndGetStartAddress(); } + else if ( ops == NVDATAMGMT_WRITE && location == NVDATAMGMT_EEPROM && startAddress == BANK7_SECTOR0_START_ADDRESS ) + { + // schedule this at the function for mfg data in sector 0 + setMemoryOpsStruct ( NVDATAMGMT_ERASE, NVDATAMGMT_EEPROM, opsStartAddress, 0, 0 ); + } + // Comments if ( length > maxBufferLength ) { quotient = length / maxBufferLength; modulus = length % maxBufferLength; for ( i = 0; i < quotient; i++ ) { setMemoryOpsStruct ( ops, location, ( opsStartAddress + ( i * maxBufferLength ) ), - data + ( i * maxBufferLength ), maxBufferLength ); + data + ( i * maxBufferLength ), maxBufferLength ); } if ( modulus != 0 ) { setMemoryOpsStruct ( ops, location, ( opsStartAddress + ( quotient * maxBufferLength ) ), - data + ( quotient * maxBufferLength ), modulus ); + data + ( quotient * maxBufferLength ), modulus ); } } else { setMemoryOpsStruct ( ops, location, opsStartAddress, data, length ); } - if ( queueFrontIndex == QUEUE_EMPTY_INDEX ) - { - queueFrontIndex++; - } } /************************************************************************* @@ -934,13 +970,17 @@ *************************************************************************/ static void dequeue ( void ) { - if ( queueFrontIndex < queueRearIndex ) + if ( queueFrontIndex >= QUEUE_MAX_SIZE - 1 ) { + queueFrontIndex = QUEUE_START_INDEX; + } + else + { queueFrontIndex++; } - else if ( queueFrontIndex == queueRearIndex ) + if ( queueCount > 0 ) { - queueFrontIndex = queueRearIndex = QUEUE_EMPTY_INDEX; + queueCount--; } } @@ -957,10 +997,12 @@ static BOOL isQueueEmpty ( void ) { BOOL isEmpty = TRUE; - if ( queueRearIndex >= QUEUE_EMPTY_INDEX + 1 ) + + if ( queueCount == 0 ) { isEmpty = FALSE; } + return isEmpty; } @@ -977,10 +1019,12 @@ static BOOL isQueueFull ( void ) { BOOL isFull = FALSE; - if ( queueRearIndex == QUEUE_MAX_SIZE - 1 ) + + if ( queueCount >= QUEUE_MAX_SIZE - 1 ) { isFull = TRUE; } + return isFull; }