1 /* -------------------------------- Arctic Core ------------------------------
\r
2 * Arctic Core - the open source AUTOSAR platform http://arccore.com
\r
4 * Copyright (C) 2009 ArcCore AB <contact@arccore.com>
\r
6 * This source code is free software; you can redistribute it and/or modify it
\r
7 * under the terms of the GNU General Public License version 2 as published by the
\r
8 * Free Software Foundation; See <http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt>.
\r
10 * This program is distributed in the hope that it will be useful, but
\r
11 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
\r
12 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
\r
14 * -------------------------------- Arctic Core ------------------------------*/
\r
20 * General requirements
\r
28 * NB! Even though some code exist for handling crc, the functionality is not complete
\r
29 * and shall not be used.
31 // 522 PC-Lint exception for empty functions
\r
32 //lint -esym(522,CalcCrc)
\r
33 //lint -emacro(904,VALIDATE_RV,VALIDATE_NO_RV) //904 PC-Lint exception to MISRA 14.7 (validate macros).
\r
35 // Exception made as a result of that NVM_DATASET_SELECTION_BITS can be zero
\r
36 //lint -emacro(835, BLOCK_BASE_AND_SET_TO_BLOCKNR) // 835 PC-lint: A zero has been given as right argument to operator '<<' or '>>'
\r
41 #include "NvM_Cbk.h"
\r
42 #include "Rte.h" // ???
\r
43 #if defined(USE_DEM)
\r
47 //#include "SchM_NvM.h"
\r
49 //#include "Crc.h" // Optional
\r
54 #define NVM_SERVICE_ID 0x00 // TODO: What number shall this ID have?
\r
56 #if ( NVM_DEV_ERROR_DETECT == STD_ON )
\r
58 #define VALIDATE(_exp,_api,_err ) \
\r
60 Det_ReportError(MODULE_ID_NVM, 0, _api, _err); \
\r
64 #define VALIDATE_RV(_exp,_api,_err,_rv ) \
\r
66 Det_ReportError(MODULE_ID_NVM, 0, _api, _err); \
\r
71 #define VALIDATE_NO_RV(_exp,_api,_err ) \
\r
73 Det_ReportError(MODULE_ID_NVM, 0, _api, _err); \
\r
76 #define DET_REPORTERROR(_module,_instance,_api,_err) Det_ReportError(_module,_instance,_api,_err)
\r
79 #define VALIDATE(_exp,_api,_err )
\r
80 #define VALIDATE_RV(_exp,_api,_err,_rv )
\r
81 #define VALIDATE_NO_RV(_exp,_api,_err )
\r
82 #define DET_REPORTERROR(_module,_instance,_api,_err)
\r
85 #define BLOCK_BASE_AND_SET_TO_BLOCKNR(_blockbase, _set) ((uint16)(_blockbase << NVM_DATASET_SELECTION_BITS) | _set)
\r
90 NVM_UNINITIALIZED = 0,
\r
92 NVM_READ_ALL_REQUESTED,
\r
93 NVM_READ_ALL_PROCESSING,
\r
94 NVM_READ_ALL_PENDING,
\r
95 NVM_WRITE_ALL_REQUESTED,
\r
96 NVM_WRITE_ALL_PROCESSING,
\r
97 NVM_WRITE_ALL_PENDING
\r
102 BLOCK_STATE_RECALC_CRC,
\r
103 BLOCK_STATE_RECALC_CRC_DONE,
\r
104 BLOCK_STATE_POSTCALC_CRC,
\r
105 BLOCK_STATE_POSTCALC_CRC_DONE,
\r
107 BLOCK_STATE_LOAD_FROM_NV,
\r
108 // BLOCK_STATE_LOAD_FROM_NV_DONE,
\r
109 // BLOCK_STATE_LOAD_FROM_NV_REDUNDANT,
\r
110 // BLOCK_STATE_LOAD_FROM_ROM,
\r
112 BLOCK_STATE_WRITE_TO_NV
\r
113 // BLOCK_STATE_WRITE_TO_NV_DONE
\r
117 static NvmStateType nvmState = NVM_UNINITIALIZED;
\r
120 BlockStateType BlockState;
\r
121 uint8 DataIndex; // Selected data index if "Data Set" type
\r
122 boolean BlockWriteProtected; // Block write protected?
\r
123 NvM_RequestResultType ErrorStatus; // Status of block
\r
124 boolean BlockChanged; // Block changed?
\r
125 boolean BlockValid; // Block valid?
\r
126 uint8 NumberOfWriteFailed; // Current write retry cycle
\r
127 } AdministrativeBlockType;
\r
129 static AdministrativeBlockType AdminBlock[NVM_NUM_OF_NVRAM_BLOCKS];
\r
132 NvM_RequestResultType ErrorStatus; // Status from multi block requests i.e. Read/Write/CancelWrite-all
\r
133 } AdministrativeMultiBlockType;
\r
135 static AdministrativeMultiBlockType AdminMultiBlock;
\r
138 * This function needs to be implemented!
140 static void CalcCrc(void)
\r
142 // TODO: Calculate CRC
\r
146 boolean JobFinished;
\r
147 Std_ReturnType JobStatus;
\r
148 MemIf_JobResultType JobResult;
\r
149 const NvM_BlockDescriptorType *BlockDescriptor;
\r
150 AdministrativeBlockType *BlockAdmin;
\r
151 } MemIfJobAdminType;
\r
153 static MemIfJobAdminType MemIfJobAdmin = {
\r
154 .JobFinished = TRUE,
\r
156 .JobResult = MEMIF_JOB_OK,
\r
157 .BlockDescriptor = NULL,
\r
162 uint16 NextBlockIndex; // Keeps track of next unfinished block
\r
163 NvM_RequestResultType PendingErrorStatus; // Status from multi block requests i.e. Read/Write/CancelWrite-all
\r
164 } AdminMultiReqType;
\r
166 static AdminMultiReqType AdminMultiReq;
\r
169 * Set the MemIf job as busy
171 static void SetMemifJobBusy()
\r
173 MemIfJobAdmin.JobFinished = FALSE;
\r
177 #if (NVM_POLLING_MODE == STD_ON)
\r
179 * Check if the MemIf job is finished
181 static boolean CheckMemIfJobFinished(void)
\r
183 MemIf_JobResultType jobResult;
\r
185 if (!MemIfJobAdmin.JobFinished) {
\r
186 jobResult = MemIf_GetJobResult();
\r
188 if (jobResult == MEMIF_JOB_OK) {
\r
189 MemIfJobAdmin.JobFinished = TRUE;
\r
190 MemIfJobAdmin.JobStatus = E_OK;
\r
191 MemIfJobAdmin.JobResult = jobResult;
\r
192 } else if (jobResult != MEMIF_JOB_PENDING) {
\r
193 MemIfJobAdmin.JobFinished = TRUE;
\r
194 MemIfJobAdmin.JobStatus = E_NOT_OK;
\r
195 MemIfJobAdmin.JobResult = jobResult;
\r
199 return MemIfJobAdmin.JobFinished;
\r
203 * Check if the MemIf job is finished
\r
205 static boolean CheckMemIfJobFinished(void)
\r
207 return MemIfJobAdmin.JobFinished;
\r
213 * Abort the MemIf job with E_NOT_OK
\r
215 static void AbortMemIfJob(MemIf_JobResultType jobResult)
\r
217 MemIfJobAdmin.JobFinished = TRUE;
\r
218 MemIfJobAdmin.JobStatus = E_NOT_OK;
\r
219 MemIfJobAdmin.JobResult = jobResult;
\r
224 * Request a read of a block from MemIf
226 static void ReadBlock(const NvM_BlockDescriptorType *blockDescriptor, AdministrativeBlockType *adminBlock, uint8 setNumber, uint8 *destAddress)
\r
228 Std_ReturnType returnCode;
\r
229 uint16 blockOffset = 0; // TODO: How to calculate this?
\r
231 if (setNumber < blockDescriptor->NvBlockNum) {
\r
233 MemIfJobAdmin.BlockAdmin = adminBlock;
\r
234 MemIfJobAdmin.BlockDescriptor = blockDescriptor;
\r
235 returnCode = MemIf_Read(blockDescriptor->NvramDeviceId, BLOCK_BASE_AND_SET_TO_BLOCKNR(blockDescriptor->NvBlockBaseNumber, setNumber), blockOffset, destAddress, blockDescriptor->NvBlockLength);
\r
236 if (returnCode != E_OK) {
\r
237 AbortMemIfJob(MEMIF_JOB_FAILED);
\r
239 } else if (setNumber < blockDescriptor->NvBlockNum + blockDescriptor->RomBlockNum) {
\r
240 // TODO: Read from ROM
\r
242 // Error: setNumber out of range
\r
243 DET_REPORTERROR(MODULE_ID_NVM, 0, NVM_LOC_READ_BLOCK_ID, NVM_PARAM_OUT_OF_RANGE);
\r
249 * Initiate the read all job
251 static void ReadAllInit(void)
\r
254 * Initiate the read all job
256 const NvM_BlockDescriptorType *BlockDescriptorList = NvM_Config.BlockDescriptor;
\r
257 AdministrativeBlockType *AdminBlockTable = AdminBlock;
\r
260 nvmState = NVM_READ_ALL_PROCESSING;
\r
261 AdminMultiReq.PendingErrorStatus = NVM_REQ_OK;
\r
262 AdminMultiReq.NextBlockIndex = 0;
\r
264 for (i = 0; i < NVM_NUM_OF_NVRAM_BLOCKS; i++) {
\r
265 if ((BlockDescriptorList->SelectBlockForReadall)
\r
266 #if (NVM_SET_RAM_BLOCK_STATUS_API == STD_ON) /** @req NVM345 */
\r
267 && ((!AdminBlockTable->BlockValid) // TODO: Check if this is to be done like this
\r
268 || (!AdminBlockTable->BlockChanged)) // TODO: Check if this is to be done like this
\r
271 VALIDATE_NO_RV(BlockDescriptorList->RamBlockDataAddress != NULL, NVM_READ_ALL_ID, NVM_E_WRONG_CONFIG);
\r
272 VALIDATE_NO_RV(BlockDescriptorList->BlockManagementType != NVM_BLOCK_DATASET, NVM_READ_ALL_ID, NVM_E_WRONG_CONFIG);
\r
273 if (BlockDescriptorList->CalcRamBlockCrc) {
\r
274 VALIDATE(BlockDescriptorList->BlockUseCrc == STD_ON, NVM_READ_ALL_ID, NVM_E_BLOCK_CONFIG);
\r
275 AdminBlockTable->BlockState = BLOCK_STATE_RECALC_CRC;
\r
277 AdminBlockTable->BlockState = BLOCK_STATE_LOAD_FROM_NV;
\r
280 AdminBlockTable->ErrorStatus = NVM_REQ_BLOCK_SKIPPED;
\r
284 BlockDescriptorList++;
\r
290 * Main function for the read all job
292 static void ReadAllMain(void)
\r
294 const NvM_BlockDescriptorType *BlockDescriptorList = NvM_Config.BlockDescriptor;
\r
295 AdministrativeBlockType *AdminBlockTable = AdminBlock;
\r
298 // Search forward to first unfinished block
\r
299 while ((AdminMultiReq.NextBlockIndex < NVM_NUM_OF_NVRAM_BLOCKS) && (AdminBlockTable[AdminMultiReq.NextBlockIndex].ErrorStatus != NVM_REQ_PENDING)) {
\r
300 AdminMultiReq.NextBlockIndex++;
\r
303 if (AdminMultiReq.NextBlockIndex == NVM_NUM_OF_NVRAM_BLOCKS) {
\r
304 // All block processed
\r
305 if (AdminMultiReq.PendingErrorStatus == NVM_REQ_OK) {
\r
306 AdminMultiBlock.ErrorStatus = NVM_REQ_OK;
\r
308 AdminMultiBlock.ErrorStatus = NVM_REQ_NOT_OK;
\r
311 nvmState = NVM_IDLE;
\r
313 if (NvM_Config.Common.MultiBlockCallback != NULL) {
\r
314 NvM_Config.Common.MultiBlockCallback(NVM_SERVICE_ID, AdminMultiBlock.ErrorStatus);
\r
318 for (i = AdminMultiReq.NextBlockIndex; (i < NVM_NUM_OF_NVRAM_BLOCKS) && (nvmState == NVM_READ_ALL_PROCESSING); i++) {
\r
319 switch (AdminBlockTable[i].BlockState) {
\r
320 case BLOCK_STATE_POSTCALC_CRC_DONE:
\r
324 case BLOCK_STATE_RECALC_CRC_DONE:
\r
325 // TODO: If CRC is ok do not reload from NVRAM
\r
326 // TODO: else reload
\r
329 case BLOCK_STATE_LOAD_FROM_NV:
\r
330 nvmState = NVM_READ_ALL_PENDING;
\r
331 ReadBlock(&BlockDescriptorList[i], &AdminBlockTable[i], 0, BlockDescriptorList[i].RamBlockDataAddress);
\r
343 * Handles the MemIf result of one block read
345 static void ReadAllCheckReadResult(void)
\r
347 if (MemIfJobAdmin.JobStatus == E_OK) {
\r
348 if (MemIfJobAdmin.BlockDescriptor->BlockUseCrc) {
\r
349 MemIfJobAdmin.BlockAdmin->BlockState = BLOCK_STATE_POSTCALC_CRC; /** @req NVM292 */
\r
351 MemIfJobAdmin.BlockAdmin->BlockState = BLOCK_STATE_IDLE;
\r
352 MemIfJobAdmin.BlockAdmin->ErrorStatus = NVM_REQ_OK;
\r
353 MemIfJobAdmin.BlockAdmin->BlockValid = TRUE;
\r
354 MemIfJobAdmin.BlockAdmin->BlockChanged = FALSE;
\r
356 if (MemIfJobAdmin.BlockDescriptor->WriteBlockOnce) {
\r
357 MemIfJobAdmin.BlockAdmin->BlockWriteProtected = TRUE;
\r
360 if (MemIfJobAdmin.BlockDescriptor->SingleBlockCallback != NULL) {
\r
361 (void)MemIfJobAdmin.BlockDescriptor->SingleBlockCallback(NVM_SERVICE_ID, MemIfJobAdmin.BlockAdmin->ErrorStatus); /** @req NVM281 */
\r
365 // TODO: Handle reread from NVRAM if type NVM_BLOCK_REDUNDANT
\r
366 // TODO: Handle read from ROM if available
\r
369 AdminMultiReq.PendingErrorStatus = NVM_REQ_NOT_OK;
\r
371 MemIfJobAdmin.BlockAdmin->BlockState = BLOCK_STATE_IDLE;
\r
372 MemIfJobAdmin.BlockAdmin->BlockValid = FALSE;
\r
373 MemIfJobAdmin.BlockAdmin->BlockChanged = FALSE;
\r
375 switch (MemIfJobAdmin.JobResult ) {
\r
376 case MEMIF_BLOCK_INVALID:
\r
377 MemIfJobAdmin.BlockAdmin->ErrorStatus = NVM_REQ_NV_INVALIDATED; /** @req NVM342 */
\r
380 case MEMIF_BLOCK_INCONSISTENT: /** @req NVM360 */
\r
381 MemIfJobAdmin.BlockAdmin->ErrorStatus = NVM_REQ_INTEGRITY_FAILED;
\r
382 #if defined(USE_DEM)
\r
383 Dem_ReportErrorStatus(NVM_E_INTEGRITY_FAILED,DEM_EVENT_STATUS_FAILED);
\r
387 case MEMIF_JOB_FAILED: /** @req NVM361 */
\r
388 MemIfJobAdmin.BlockAdmin->ErrorStatus = NVM_REQ_NOT_OK;
\r
389 #if defined(USE_DEM)
\r
390 Dem_ReportErrorStatus(NVM_E_REQ_FAILED,DEM_EVENT_STATUS_FAILED);
\r
395 MemIfJobAdmin.BlockAdmin->ErrorStatus = NVM_REQ_NOT_OK;
\r
399 if (MemIfJobAdmin.BlockDescriptor->SingleBlockCallback != NULL) {
\r
400 (void)MemIfJobAdmin.BlockDescriptor->SingleBlockCallback(NVM_SERVICE_ID, MemIfJobAdmin.BlockAdmin->ErrorStatus); /** @req NVM281 */
\r
403 nvmState = NVM_READ_ALL_PROCESSING;
\r
408 * Request writing of a block to MemIf
410 static void WriteBlock(const NvM_BlockDescriptorType *blockDescriptor, AdministrativeBlockType *adminBlock, uint8 setNumber, uint8 *sourceAddress)
\r
412 Std_ReturnType returnCode;
\r
414 if (setNumber < blockDescriptor->NvBlockNum) {
\r
416 MemIfJobAdmin.BlockAdmin = adminBlock;
\r
417 MemIfJobAdmin.BlockDescriptor = blockDescriptor;
\r
418 returnCode = MemIf_Write(blockDescriptor->NvramDeviceId, BLOCK_BASE_AND_SET_TO_BLOCKNR(blockDescriptor->NvBlockBaseNumber, setNumber), sourceAddress);
\r
419 if (returnCode != E_OK) {
\r
420 AbortMemIfJob(MEMIF_JOB_FAILED);
\r
423 // Error: setNumber out of range
\r
424 DET_REPORTERROR(MODULE_ID_NVM, 0, NVM_LOC_WRITE_BLOCK_ID, NVM_PARAM_OUT_OF_RANGE);
\r
430 * Initiate the write all job
\r
432 static void WriteAllInit(void)
\r
434 const NvM_BlockDescriptorType *BlockDescriptorList = NvM_Config.BlockDescriptor;
\r
435 AdministrativeBlockType *AdminBlockTable = AdminBlock;
\r
438 nvmState = NVM_WRITE_ALL_PROCESSING;
\r
439 AdminMultiReq.PendingErrorStatus = NVM_REQ_OK;
\r
440 AdminMultiReq.NextBlockIndex = 0;
\r
442 for (i = 0; i < NVM_NUM_OF_NVRAM_BLOCKS; i++) {
\r
443 if ((BlockDescriptorList->RamBlockDataAddress != NULL)
\r
444 #if (NVM_SET_RAM_BLOCK_STATUS_API == STD_ON) /** @req NVM344 */
\r
445 && (AdminBlockTable->BlockValid) /** @req NVM682 */
\r
446 && (AdminBlockTable->BlockChanged) /** @req NVM682 */
\r
448 && (!AdminBlockTable->BlockWriteProtected)){ /** @req NVM432 *//** @req NVM433 */
\r
449 if (BlockDescriptorList->BlockUseCrc) {
\r
450 AdminBlockTable->BlockState = BLOCK_STATE_RECALC_CRC; /** @req NVM253 */
\r
452 AdminBlockTable->BlockState = BLOCK_STATE_WRITE_TO_NV;
\r
453 AdminBlockTable->NumberOfWriteFailed = 0;
\r
456 AdminBlockTable->ErrorStatus = NVM_REQ_BLOCK_SKIPPED; /** @req NVM298 */
\r
460 BlockDescriptorList++;
\r
466 * Main function for the write all job
\r
468 static void WriteAllMain(void)
\r
470 const NvM_BlockDescriptorType *BlockDescriptorList = NvM_Config.BlockDescriptor;
\r
471 AdministrativeBlockType *AdminBlockTable = AdminBlock;
\r
474 // Search forward to first unfinished block
\r
475 while ((AdminMultiReq.NextBlockIndex < NVM_NUM_OF_NVRAM_BLOCKS) && (AdminBlockTable[AdminMultiReq.NextBlockIndex].ErrorStatus != NVM_REQ_PENDING)) {
\r
476 AdminMultiReq.NextBlockIndex++;
\r
479 if (AdminMultiReq.NextBlockIndex == NVM_NUM_OF_NVRAM_BLOCKS) {
\r
480 // All block processed
\r
481 if (AdminMultiReq.PendingErrorStatus == NVM_REQ_OK) {
\r
482 AdminMultiBlock.ErrorStatus = NVM_REQ_OK;
\r
484 AdminMultiBlock.ErrorStatus = NVM_REQ_NOT_OK;
\r
487 nvmState = NVM_IDLE;
\r
489 if (NvM_Config.Common.MultiBlockCallback != NULL) {
\r
490 NvM_Config.Common.MultiBlockCallback(NVM_SERVICE_ID, AdminMultiBlock.ErrorStatus);
\r
494 for (i = AdminMultiReq.NextBlockIndex; (i < NVM_NUM_OF_NVRAM_BLOCKS) && (nvmState == NVM_WRITE_ALL_PROCESSING); i++) {
\r
495 switch (AdminBlockTable[i].BlockState) {
\r
496 case BLOCK_STATE_POSTCALC_CRC_DONE:
\r
500 case BLOCK_STATE_RECALC_CRC_DONE:
\r
501 // TODO: If CRC is ok do not reload from NVRAM
\r
502 // TODO: else reload
\r
505 case BLOCK_STATE_WRITE_TO_NV:
\r
506 nvmState = NVM_WRITE_ALL_PENDING;
\r
507 WriteBlock(&BlockDescriptorList[i], &AdminBlockTable[i], 0, BlockDescriptorList[i].RamBlockDataAddress);
\r
519 * Handles the result of one MemIf block write
\r
521 static void WriteAllCheckWriteResult(void)
\r
523 if (MemIfJobAdmin.JobStatus == E_OK) {
\r
524 // TODO: Check if redundant block shall be written NVM337
\r
526 if (MemIfJobAdmin.BlockDescriptor->WriteBlockOnce) {
\r
527 MemIfJobAdmin.BlockAdmin->BlockWriteProtected = TRUE; /** @req NVM329 */
\r
529 MemIfJobAdmin.BlockAdmin->BlockState = BLOCK_STATE_IDLE;
\r
530 MemIfJobAdmin.BlockAdmin->ErrorStatus = NVM_REQ_OK;
\r
532 if (MemIfJobAdmin.BlockDescriptor->SingleBlockCallback != NULL) {
\r
533 (void)MemIfJobAdmin.BlockDescriptor->SingleBlockCallback(NVM_SERVICE_ID, MemIfJobAdmin.BlockAdmin->ErrorStatus);
\r
536 MemIfJobAdmin.BlockAdmin->NumberOfWriteFailed++;
\r
537 if (MemIfJobAdmin.BlockAdmin->NumberOfWriteFailed > NVM_MAX_NUMBER_OF_WRITE_RETRIES) {
\r
538 // TODO: Check if redundant block shall be written NVM337
\r
540 // Write has failed
\r
541 AdminMultiReq.PendingErrorStatus = NVM_REQ_NOT_OK;
\r
543 MemIfJobAdmin.BlockAdmin->BlockState = BLOCK_STATE_IDLE;
\r
544 MemIfJobAdmin.BlockAdmin->ErrorStatus = NVM_REQ_NOT_OK; /** @req NVM296 */
\r
545 #if defined(USE_DEM)
\r
546 Dem_ReportErrorStatus(NVM_E_REQ_FAILED,DEM_EVENT_STATUS_FAILED);
\r
549 if (MemIfJobAdmin.BlockDescriptor->SingleBlockCallback != NULL) {
\r
550 (void)MemIfJobAdmin.BlockDescriptor->SingleBlockCallback(NVM_SERVICE_ID, MemIfJobAdmin.BlockAdmin->ErrorStatus);
\r
554 nvmState = NVM_WRITE_ALL_PROCESSING;
\r
558 /***************************************
\r
559 * External accessible functions *
\r
560 ***************************************/
\r
562 * Procedure: NvM_Init
\r
565 void NvM_Init(void)
\r
567 /** @req NVM399 *//** @req NVM193 */
\r
568 const NvM_BlockDescriptorType *BlockDescriptorList = NvM_Config.BlockDescriptor;
\r
569 AdministrativeBlockType *AdminBlockTable = AdminBlock;
\r
572 // Initiate the administration blocks
\r
573 for (i = 0; i< NVM_NUM_OF_NVRAM_BLOCKS; i++) {
\r
574 if (BlockDescriptorList->BlockManagementType == NVM_BLOCK_DATASET) {
\r
575 AdminBlockTable->DataIndex = 0; /** @req NVM192 */
\r
577 AdminBlockTable->BlockWriteProtected = BlockDescriptorList->BlockWriteProt;
\r
578 AdminBlockTable->ErrorStatus = NVM_REQ_NOT_OK;
\r
579 AdminBlockTable->BlockChanged = FALSE;
\r
580 AdminBlockTable->BlockValid = FALSE;
\r
581 AdminBlockTable->NumberOfWriteFailed = 0;
\r
584 BlockDescriptorList++;
\r
587 AdminMultiBlock.ErrorStatus = NVM_REQ_NOT_OK;
\r
589 // Set status to initialized
\r
590 nvmState = NVM_IDLE; /** @req NVM399 */
\r
595 * Procedure: NvM_ReadAll
\r
598 void NvM_ReadAll(void)
\r
600 AdministrativeBlockType *AdminBlockTable = AdminBlock;
\r
603 VALIDATE_NO_RV(nvmState != NVM_UNINITIALIZED, NVM_READ_ALL_ID, NVM_E_NOT_INITIALIZED);
\r
605 // TODO: Check queue
\r
608 if (nvmState == NVM_IDLE) {
\r
609 nvmState = NVM_READ_ALL_REQUESTED; /** @req NVM243 */
\r
611 // Set status to pending in the administration blocks
\r
612 AdminMultiBlock.ErrorStatus = NVM_REQ_PENDING;
\r
614 for (i = 0; i < NVM_NUM_OF_NVRAM_BLOCKS; i++) {
\r
615 AdminBlockTable->ErrorStatus = NVM_REQ_PENDING;
\r
623 * Procedure: NvM_WriteAll
\r
626 void NvM_WriteAll(void)
\r
628 AdministrativeBlockType *AdminBlockTable = AdminBlock;
\r
631 VALIDATE_NO_RV(nvmState != NVM_UNINITIALIZED, NVM_READ_ALL_ID, NVM_E_NOT_INITIALIZED);
\r
633 // TODO: Check queue
\r
636 if (nvmState == NVM_IDLE) {
\r
637 nvmState = NVM_WRITE_ALL_REQUESTED; /** @req NVM254 */
\r
639 // Set status to pending in the administration blocks
\r
640 AdminMultiBlock.ErrorStatus = NVM_REQ_PENDING;
\r
642 for (i = 0; i < NVM_NUM_OF_NVRAM_BLOCKS; i++) {
\r
643 AdminBlockTable->ErrorStatus = NVM_REQ_PENDING; /** @req NVM549 */
\r
651 * Procedure: NvM_CancelWriteAll
\r
654 void NvM_CancelWriteAll(void)
\r
661 * Procedure: NvM_GetErrorStatus
\r
664 void NvM_GetErrorStatus(NvM_BlockIdType blockId, uint8 *requestResultPtr)
\r
666 VALIDATE_NO_RV(nvmState != NVM_UNINITIALIZED, NVM_GET_ERROR_STATUS_ID, NVM_E_NOT_INITIALIZED);
\r
667 VALIDATE_NO_RV(blockId < NVM_NUM_OF_NVRAM_BLOCKS+1, NVM_GET_ERROR_STATUS_ID, NVM_E_PARAM_BLOCK_ID);
\r
669 if (blockId == 0) {
\r
671 *requestResultPtr = AdminMultiBlock.ErrorStatus;
\r
673 *requestResultPtr = AdminBlock[blockId-1].ErrorStatus;
\r
679 #if (NVM_SET_RAM_BLOCK_STATUS_API == STD_ON) /** @req NVM408 */
\r
681 * Procedure: Nvm_SetRamBlockStatus
\r
684 void Nvm_SetRamBlockStatus(NvM_BlockIdType blockId, boolean blockChanged)
\r
686 const NvM_BlockDescriptorType *BlockDescriptorList = NvM_Config.BlockDescriptor;
\r
688 VALIDATE_NO_RV(nvmState != NVM_UNINITIALIZED, NVM_SET_RAM_BLOCK_STATUS_ID, NVM_E_NOT_INITIALIZED); /** @req NVM497 */
\r
689 VALIDATE_NO_RV(blockId < NVM_NUM_OF_NVRAM_BLOCKS+1, NVM_SET_RAM_BLOCK_STATUS_ID, NVM_E_PARAM_BLOCK_ID);
\r
690 VALIDATE_NO_RV(blockId > 1, NVM_SET_RAM_BLOCK_STATUS_ID, NVM_E_PARAM_BLOCK_ID);
\r
692 if (BlockDescriptorList[blockId-1].RamBlockDataAddress != NULL) { /** @req NVM240 */
\r
693 if (blockChanged) {
\r
694 AdminBlock[blockId-1].BlockChanged = TRUE; /** @req NVM406 */
\r
695 AdminBlock[blockId-1].BlockValid = TRUE; /** @req NVM241 */
\r
696 if (BlockDescriptorList[blockId-1].BlockUseCrc) {
\r
697 AdminBlock[blockId-1].BlockState = BLOCK_STATE_RECALC_CRC; /** @req NVM121 */
\r
700 AdminBlock[blockId-1].BlockChanged = FALSE; /** @req NVM405 */
\r
701 AdminBlock[blockId-1].BlockValid = FALSE;
\r
702 } // else blockChanged
\r
703 } // if permanent block
\r
708 /***************************************
\r
709 * Scheduled functions *
\r
710 ***************************************/
\r
712 * Procedure: NvM_MainFunction
\r
715 void NvM_MainFunction(void)
\r
717 switch (nvmState) {
\r
718 case NVM_UNINITIALIZED:
\r
725 case NVM_READ_ALL_REQUESTED:
\r
729 case NVM_READ_ALL_PROCESSING:
\r
730 if (MemIf_GetStatus() == MEMIF_IDLE) {
\r
736 case NVM_READ_ALL_PENDING:
\r
737 if (CheckMemIfJobFinished()) {
\r
738 ReadAllCheckReadResult();
\r
743 case NVM_WRITE_ALL_REQUESTED:
\r
747 case NVM_WRITE_ALL_PROCESSING:
\r
748 if (MemIf_GetStatus() == MEMIF_IDLE) {
\r
754 case NVM_WRITE_ALL_PENDING:
\r
755 if (CheckMemIfJobFinished()) {
\r
756 WriteAllCheckWriteResult();
\r
762 DET_REPORTERROR(MODULE_ID_NVM, 0, NVM_MAIN_FUNCTION_ID, NVM_UNEXPECTED_STATE);
\r
768 /***************************************
\r
769 * Call-back notifications functions *
\r
770 ***************************************/
\r
771 #if (NVM_POLLING_MODE == STD_OFF)
\r
773 * Procedure: NvM_JobEndNotification
\r
776 void NvM_JobEndNotification(void)
\r
778 MemIfJobAdmin.JobFinished = TRUE;
\r
779 MemIfJobAdmin.JobStatus = E_OK;
\r
780 MemIfJobAdmin.JobResult = MemIf_GetJobResult();
\r
784 * Procedure: NvM_JobErrorNotification
\r
787 void NvM_JobErrorNotification(void)
\r
789 MemIfJobAdmin.JobFinished = TRUE;
\r
790 MemIfJobAdmin.JobStatus = E_NOT_OK;
\r
791 MemIfJobAdmin.JobResult = MemIf_GetJobResult();
\r