#ifdef ENABLE_QAC_TEST #pragma PRQA_MESSAGES_OFF 0292 #endif /********************************************************************************************************************* * Library : Data Flash Access Library for Renesas RH850 devices * * File Name : $Source: r_fdl_user_if.c $ * Lib. Version : $RH850_FDL_LIB_VERSION_T01: V2.11 $ * Mod. Revision : $Revision: 1.52 $ * Mod. Date : $Date: 2016/06/01 12:39:21JST $ * Device(s) : RV40 Flash based RH850 microcontroller * Description : FDL user interface functions *********************************************************************************************************************/ /********************************************************************************************************************* * DISCLAIMER * This software is supplied by Renesas Electronics Corporation and is only intended for use with Renesas products. * No other uses are authorized. This software is owned by Renesas Electronics Corporation and is protected under all * applicable laws, including copyright laws. * THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING THIS SOFTWARE, WHETHER EXPRESS, IMPLIED * OR STATUTORY, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. * TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS ELECTRONICS CORPORATION NOR ANY OF ITS * AFFILIATED COMPANIES SHALL BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR ANY * REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGES. * Renesas reserves the right, without notice, to make changes to this software and to discontinue the availability of * this software. By using this software, you agree to the additional terms and conditions found by accessing the * following link: * http://www.renesas.com/disclaimer * * Copyright (C) 2015-2016 Renesas Electronics Corporation. All rights reserved. *********************************************************************************************************************/ #ifdef ENABLE_QAC_TEST #pragma PRQA_MESSAGES_ON 0292 #endif /********************************************************************************************************************* * MISRA Rule: MISRA-C 2004 rule 3.1 (QAC message 0292) * Reason: To support automatic insertion of revision, module name etc. by the source revision control system * it is necessary to violate the rule, because the system uses non basic characters as placeholders. * Verification: The placeholders are used in commentaries only. Therefore rule violation cannot influence code * compilation. *********************************************************************************************************************/ /********************************************************************************************************************* * MISRA Rule: MISRA-C 2004 rule 11.3 (QAC message 0306) * Reason: For effective embedded programming, integer to pointer conversions are used * Verification: The converted addresses are essential for complete code execution. Incorrect * conversion would result in test fails. *********************************************************************************************************************/ /********************************************************************************************************************* * MISRA Rule: MISRA-C 2004 rule 14.1 (QAC message 1503) * Reason: This function is not used within the library, it is only used by the user * application. * Verification: This function is part of the library API and therefore essential on the one hand. * On the other hand the QAC warning is correct, because this function is never * called within the library. To solve this dilemma it is necessary and suitable * to disable the message. *********************************************************************************************************************/ /********************************************************************************************************************* * MISRA Rule: MISRA-C 2004 rule 19.1 (QAC message 5087) * Reason: The section mapping concept (Mapping code, constants and data to specific linker sections) bases on * a central include file containing all section mapping defines and pragmas. This need to be included * multiple times within the code. The file itself only contains those defines and pragmas. * Verification: This is the standard concept defined for AUTOSAR implementations *********************************************************************************************************************/ /********************************************************************************************************************* * MISRA Rule: MISRA-C 2004 rule 9.1 (QAC message 2962) * Reason: Apparent using value of an uninitialized variable fcuCmd, used to convert API commands * (see r_fdl_command_t enum) into commands passed to the hardware. * Verification: The variable fcuCmd is set properly for all commands except R_FDL_CMD_READ, for which is not used * at all. *********************************************************************************************************************/ #define R_FDL_USERIF_C /********************************************************************************************************************* * FDL header files include *********************************************************************************************************************/ #include "r_fdl_global.h" /********************************************************************************************************************* * Module internal function prototypes *********************************************************************************************************************/ R_FDL_STATIC void R_FDL_UFct_EndCurrentOperation (r_fdl_status_t ret_enu); R_FDL_STATIC r_fdl_flag_t R_FDL_UFct_FlashOpStart (r_fdl_request_t * request_pstr, r_fdl_status_t * tmpStat_penu, r_fdl_flag_t isCalledFromExecute_enu); R_FDL_STATIC r_fdl_flag_t R_FDL_Handler_BusyAndSuspendPossible (void); R_FDL_STATIC r_fdl_flag_t R_FDL_Handler_ChkResume (r_fdl_status_t * tmpStat_penu); R_FDL_STATIC r_fdl_flag_t R_FDL_Handler_ReactOnFatalErrors (r_fdl_status_t * tmpStat_penu); R_FDL_STATIC r_fdl_flag_t R_FDL_Handler_StatusCheckAndSuspendOnReady (r_fdl_status_t * tmpStat_penu); R_FDL_STATIC r_fdl_flag_t R_FDL_Handler_MultiOperation (r_fdl_status_t * tmpStat_penu); R_FDL_STATIC r_fdl_flag_t R_FDL_UFct_StateNotStandBy (void); R_FDL_STATIC r_fdl_flag_t R_FDL_Handler_OperationStates (r_fdl_status_t * tmpStat_penu); R_FDL_STATIC r_fdl_flag_t R_FDL_Handler_CancelReq (r_fdl_status_t * tmpStat_penu); /********************************************************************************************************************* * Global variables *********************************************************************************************************************/ /********************************************************************************************************************* * MISRA Rule: QAC message 2022 * Reason: Basically, global variables should be initialized. However, as the library is used for multiple * compilers and not all compilers support explicit initialization for variables in not standard * sections, this variable is initialized in the library initialization function rather than by the * compiler. * Verification: test case *********************************************************************************************************************/ /* Note: * The define "R_FDL_COV_ENABLED" is a specific define for library testing purpose only. * The user application shall not set this define */ #if (!defined R_FDL_COV_ENABLED) #define R_FDL_START_SEC_VAR #include "r_fdl_mem_map.h" /* PRQA S 5087 */ R_FDL_NOINIT r_fdl_data_t g_fdl_str; /* PRQA S 2022 */ #define R_FDL_STOP_SEC_VAR #include "r_fdl_mem_map.h" /* PRQA S 5087 */ #ifndef R_FDL_EXE_INIT_CODE_ON_STACK #define R_FDL_START_SEC_CODERAM #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /* Code size calculation described in r_fdl_global.h */ R_FDL_NOINIT uint16_t g_fdl_ramCodeBuf_au16[R_FDL_RAM_CODE_SIZE_HW]; /* PRQA S 2022 */ #define R_FDL_STOP_SEC_CODERAM #include "r_fdl_mem_map.h" /* PRQA S 5087 */ #endif #else /* #if (!defined R_FDL_COV_ENABLED) */ R_FDL_NOINIT r_fdl_data_t g_fdl_str; /* PRQA S 2022 */ #ifndef R_FDL_EXE_INIT_CODE_ON_STACK R_FDL_NOINIT uint16_t g_fdl_ramCodeBuf_au16[R_FDL_RAM_CODE_SIZE_HW]; /* PRQA S 2022 */ #endif #endif /* #else #if (!defined R_FDL_COV_ENABLED) */ /********************************************************************************************************************* * Function name: R_FDL_InitVariables *********************************************************************************************************************/ /** * Part of the R_FDL_Init function. * This function initializes the FDL internal variables and does the FDL configuration parameter checks. * The following parameter checks are done: * - Descriptor variable is defined * - FDL pool is defined * - EEL pool is within FDL pool * * In error case the library is set to not initialized (R_FDL_ISTAT_NOINIT) * * @param[in] descriptor_pstr - Pointer to the FDL descriptor structure * @return Initialization status when returned from function call: * - R_FDL_OK - Initialization was successful * - R_FDL_ERR_CONFIGURATION - FDL configuration parameter error */ /*********************************************************************************************************************/ /********************************************************************************************************************* * MISRA Rule: MISRA-C 2004 rule 8.8 (QAC message 3408) * Reason: Library is delivered as source code and as a precompiled object. * The file r_fdl_user_if_init.c is not included on generation of the precompiled object. * It is delivered as a separate file and cannot include any other header files, except the * defined interface header files. The function is a library internal function and its declaration * is not part of the interface header files. * Verification: - *********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ r_fdl_status_t R_FDL_InitVariables (const r_fdl_descriptor_t * descriptor_pstr) /* PRQA S 3408 */ { r_fdl_status_t ret; uint32_t fdAdd; uint32_t i; uint16_t blkEnd; /* Initially clear the complete r_fdl_data structure */ fdAdd = (uint32_t)(&g_fdl_str); /* PRQA S 0306 */ for (i = 0; i < sizeof (g_fdl_str); i++) { R_FDL_IFct_WriteMemoryU08 (fdAdd, 0u); fdAdd++; } g_fdl_str.iStat_enu = R_FDL_ISTAT_NOINIT; ret = R_FDL_OK; /* We have a descriptor at all */ if (R_FDL_DESCRIPTOR_POINTER_UNDEFINED != descriptor_pstr) { /* Set pointer to FDL static configuration */ g_fdl_str.RTCfg_pstr = descriptor_pstr; /* Parameter independent initializations */ (g_fdl_str.reqSuspend_pstr) = R_FDL_REQUEST_POINTER_UNDEFINED; (g_fdl_str.reqInt_pstr) = R_FDL_REQUEST_POINTER_UNDEFINED; /* Reset misc flags */ g_fdl_str.cancelRequest_enu = R_FDL_FALSE; g_fdl_str.spdSpdRequest_enu = R_FDL_FALSE; g_fdl_str.spdResRequest_enu = R_FDL_FALSE; g_fdl_str.flashMode_u16 = R_FCU_MODE_USER; g_fdl_str.opStatus_enu = R_FDL_OP_IDLE; /* FDL Pool is available */ if (0u != g_fdl_str.RTCfg_pstr->fdlPoolSize_u16) { blkEnd = (g_fdl_str.RTCfg_pstr->eelPoolStart_u16) + (g_fdl_str.RTCfg_pstr->eelPoolSize_u16); /* EEL Pool fits into FDL pool */ if (blkEnd >= (g_fdl_str.RTCfg_pstr->fdlPoolSize_u16 + 1u) ) { ret = R_FDL_ERR_CONFIGURATION; } } else { ret = R_FDL_ERR_CONFIGURATION; } } /* We don't have a descriptor at all */ else { ret = R_FDL_ERR_CONFIGURATION; } /* Only if no error occurred, the library status is set to initialized */ if (R_FDL_OK == ret) { g_fdl_str.iStat_enu = R_FDL_ISTAT_INIT; } return (ret); } /* R_FDL_InitVariables */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_Execute *********************************************************************************************************************/ /** * User interface function: * This function initiates a Flash operation (Erase/Write/Read/Prepare Environment). * After initiation, the function R_FDL_Handler need to be called regularly to finish the operation. * * @param[in, out] request_pstr Pointer to the operation request structure. * - Structure input elements: \n * command_enu, bufAddr_u32, idx_u32, cnt_u16, accessType_enu * - Structure output element: \n * status_enu * @return --- */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ void R_FDL_Execute (r_fdl_request_t * request_pstr) /* PRQA S 1503 */ { r_fdl_status_t reqErr; reqErr = R_FDL_ERR_REJECTED; /* Request structure pointer parameter is not "0x00" */ if (R_FDL_REQUEST_POINTER_UNDEFINED != request_pstr) { /* library internal request structure pointer is "0x00" (No operation ongoing) */ if (R_FDL_REQUEST_POINTER_UNDEFINED == g_fdl_str.reqInt_pstr) { /* Library is initialized */ if (R_FDL_ISTAT_INIT == g_fdl_str.iStat_enu) { /* Only Prepare command is allowed when teh library is in initialized status */ if (R_FDL_CMD_PREPARE_ENV == request_pstr->command_enu) { reqErr = R_FDL_FCUFct_SwitchMode_Start (R_FCU_MODE_PE); /* No invalid FACI programming mode detected */ if (R_FDL_OK == reqErr) { reqErr = R_FDL_BUSY; g_fdl_str.opStatus_enu = R_FDL_OP_EXECUTE_SYNC_ON; } } } /* Library is prepared and not busy and no cancel request */ else if ( (R_FDL_ISTAT_NORMALOP == g_fdl_str.iStat_enu) || ( (R_FDL_ISTAT_SUSPENDED == g_fdl_str.iStat_enu) && (R_FDL_FALSE == g_fdl_str.cancelRequest_enu) ) ) { /* Command selection */ switch (request_pstr->command_enu) { case R_FDL_CMD_BLANKCHECK: { (void)R_FDL_UFct_FlashOpStart (request_pstr, &reqErr, R_FDL_TRUE); break; } #if (defined ENABLE_CMD_WRITE16B) case R_FDL_CMD_WRITE16B: #endif case R_FDL_CMD_ERASE: case R_FDL_CMD_WRITE: { /* Check FACI suspend flags points out that the command can be started */ if (R_FDL_TRUE == R_FDL_FCUFct_ChkStartable (request_pstr->command_enu) ) { (void)R_FDL_UFct_FlashOpStart (request_pstr, &reqErr, R_FDL_TRUE); } break; } case R_FDL_CMD_READ: { (void)R_FDL_UFct_FlashOpStart (request_pstr, &reqErr, R_FDL_TRUE); break; } case R_FDL_CMD_PREPARE_ENV: { reqErr = R_FDL_ERR_REJECTED; break; } default: { reqErr = R_FDL_ERR_COMMAND; break; } } /* switch */ } else { /* Nothing to do, added to fix QAC warning message 2004 */ } } /* Command execution started */ if (R_FDL_BUSY == reqErr) { /* set internal pointer to the request structure, required by the handler */ g_fdl_str.reqInt_pstr = request_pstr; } /* Command execution rejected */ else { /* At operations end (In error case or if the operation requires no handler calls), reset the access type */ request_pstr->accessType_enu = R_FDL_ACCESS_NONE; g_fdl_str.opStatus_enu = R_FDL_OP_IDLE; } /* Set the return state */ request_pstr->status_enu = reqErr; } return; } /* R_FDL_Execute */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_Handler_CancelReq *********************************************************************************************************************/ /** * Part of the R_FDL_Handler function. * This function cancels an ongoing Flash operation if: * - cancel request flag set * - switch mode is performed * * @param[out] tmpStat_penu - Status return value. Is modified, if an operation is cancelled. * @return handler function flow may continue after this function or handler need to exit * - R_FDL_TRUE - continue handler * - R_FDL_FALSE - exit handler */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ R_FDL_STATIC r_fdl_flag_t R_FDL_Handler_CancelReq (r_fdl_status_t * tmpStat_penu) { r_fdl_flag_t cont; r_fdl_status_t res; cont = R_FDL_TRUE; /* Only do something is cancel request flag is not already set */ if (R_FDL_TRUE == g_fdl_str.cancelRequest_enu) { if (R_FDL_OK == R_FDL_FCUFct_SwitchMode_Check() ) { /* FACI in programming mode */ if (R_FCU_MODE_PE == g_fdl_str.flashMode_u16) { res = R_FDL_FCUFct_ForcedStop(); /* Timeout error in forced stop - internal error Note: If FACI remains busy, it might happen that a mode switch will not be performed. Thus, don't try to do it but finish with internal error immediately. This means that DF is possibly not readable */ if (R_FDL_OK != res) { (*tmpStat_penu) = R_FDL_ERR_INTERNAL; cont = R_FDL_FALSE; } /* After forced stop, switch to user mode */ else { (void)R_FDL_FCUFct_SwitchMode_Start (R_FCU_MODE_USER); g_fdl_str.opResult_enu = R_FDL_CANCELLED; (*tmpStat_penu) = R_FDL_BUSY; g_fdl_str.opStatus_enu = R_FDL_OP_END_SYNC_OFF; } } /* FACI is idle */ else { (*tmpStat_penu) = R_FDL_CANCELLED; cont = R_FDL_FALSE; } g_fdl_str.cancelRequest_enu = R_FDL_FALSE; g_fdl_str.spdSpdRequest_enu = R_FDL_FALSE; g_fdl_str.spdResRequest_enu = R_FDL_FALSE; g_fdl_str.iStat_enu = R_FDL_ISTAT_NORMALOP; /* In case of suspended Flash operation, also the suspended operation's request structure need to be updated */ if (R_FDL_REQUEST_POINTER_UNDEFINED != g_fdl_str.reqSuspend_pstr) { g_fdl_str.reqSuspend_pstr->status_enu = R_FDL_CANCELLED; g_fdl_str.reqSuspend_pstr = R_FDL_REQUEST_POINTER_UNDEFINED; } } else { cont = R_FDL_FALSE; } } return (cont); } /* R_FDL_Handler_CancelReq */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_Handler_BusyAndSuspendPossible *********************************************************************************************************************/ /** * Part of the R_FDL_Handler function. * This function suspends an ongoing Flash operation if: * - suspend request flag set * - function is suspendable * * @param[in,out] - * @return Handler function flow may continue afte this function or handler need to exit * - R_FDL_TRUE - continue handler * - R_FDL_FALSE - exit handler */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ R_FDL_STATIC r_fdl_flag_t R_FDL_Handler_BusyAndSuspendPossible (void) { r_fdl_flag_t cont; cont = R_FDL_TRUE; /* Handle a suspend request */ if (R_FDL_TRUE == g_fdl_str.spdSpdRequest_enu) { /* FACI allows suspending */ if (R_FDL_TRUE == R_FDL_FCUFct_ChkSuspendable() ) { /* Must be called before changing g_fdl_str.iStat_enu because g_fdl_str.iStat_enu is checked in R_FDL_Standby! */ R_FDL_FCUFct_Suspend(); g_fdl_str.spdSpdRequest_enu = R_FDL_FALSE; g_fdl_str.iStat_enu = R_FDL_ISTAT_SUSPEND_PR; cont = R_FDL_FALSE; } } return (cont); } /* R_FDL_Handler_BusyAndSuspendPossible */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_Handler_ChkResume *********************************************************************************************************************/ /** * Part of the R_FDL_Handler function. * This function resumes a suspended Flash operation if: * - resume request flag set (can only be set if a function was suspended) * - No Flash operation is ongoing * * @param[out] tmpStat_penu - Status return value. Is modified, if an operation is resumed. * @return handler function flow may continue after this function or handler need to exit: * - R_FDL_TRUE - continue handler * - R_FDL_FALSE - exit handler */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ R_FDL_STATIC r_fdl_flag_t R_FDL_Handler_ChkResume (r_fdl_status_t * tmpStat_penu) { r_fdl_flag_t cont; r_fdl_status_t res; cont = R_FDL_FALSE; /* Resume request flag set and no operation ongoing */ if ( (R_FDL_REQUEST_POINTER_UNDEFINED == g_fdl_str.reqInt_pstr) && (R_FDL_TRUE == g_fdl_str.spdResRequest_enu) ) { g_fdl_str.spdResRequest_enu = R_FDL_FALSE; /* We need to resume a Flash operation */ if (R_FDL_BUSY == g_fdl_str.spdResStatus_enu) { res = R_FDL_FCUFct_SwitchMode_Start (R_FCU_MODE_PE); /* protection error during mode switching */ if (R_FDL_OK != res) { g_fdl_str.reqSuspend_pstr->status_enu = res; } /* Continue resuming */ else { g_fdl_str.opStatus_enu = R_FDL_OP_RESUME_SYNC_ON; cont = R_FDL_TRUE; g_fdl_str.iStat_enu = R_FDL_ISTAT_NORMALOP; } } /* We need to resume to command execution end or to start of a new Flash operation */ else { /* In order to support continuing Multi-Operations, we need to patch the R_FDL_OK to R_FDL_BUSY. Errors result in operation end (Write, Erase, BC errors) */ if ( (R_FDL_OK == g_fdl_str.spdResStatus_enu) && (g_fdl_str.spdMulOp_str.flashAdd_u32 < g_fdl_str.spdMulOp_str.flashAddEnd_u32) ) { res = R_FDL_FCUFct_SwitchMode_Start (R_FCU_MODE_PE); /* protection error during mode switching */ if (R_FDL_OK != res) { g_fdl_str.reqSuspend_pstr->status_enu = res; } /* Continue with next resume step */ else { g_fdl_str.opStatus_enu = R_FDL_OP_RESUME_MULTI_SYNC_ON; g_fdl_str.spdResStatus_enu = R_FDL_BUSY; cont = R_FDL_TRUE; g_fdl_str.iStat_enu = R_FDL_ISTAT_NORMALOP; } } /* Operation ends */ else { g_fdl_str.iStat_enu = R_FDL_ISTAT_NORMALOP; (*tmpStat_penu) = g_fdl_str.spdResStatus_enu; } } /* on successful resume, restore the FDL operation data */ if (R_FDL_ISTAT_SUSPENDED != g_fdl_str.iStat_enu) { /* Restore variables for resume */ g_fdl_str.reqInt_pstr = g_fdl_str.reqSuspend_pstr; /* if operation finished, the result will be set in the end of the handler function */ g_fdl_str.reqInt_pstr->status_enu = R_FDL_BUSY; g_fdl_str.reqSuspend_pstr = R_FDL_REQUEST_POINTER_UNDEFINED; g_fdl_str.mulOp_str.flashAdd_u32 = g_fdl_str.spdMulOp_str.flashAdd_u32; g_fdl_str.mulOp_str.bufAdd_u32 = g_fdl_str.spdMulOp_str.bufAdd_u32; g_fdl_str.mulOp_str.flashAddEnd_u32 = g_fdl_str.spdMulOp_str.flashAddEnd_u32; g_fdl_str.mulOp_str.accessType_enu = g_fdl_str.spdMulOp_str.accessType_enu; } } else { cont = R_FDL_TRUE; } return (cont); } /* R_FDL_Handler_ChkResume */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_Handler_ReactOnFatalErrors *********************************************************************************************************************/ /** * Part of the R_FDL_Handler function. * Read out Flash operation error status after operation end and react on fatal errors. * * @param[out] tmpStat_penu - Status return value. Is set to internal error in case of detection * of a fatal HW error * @return handler function flow may continue after this function or handler need to exit: * - R_FDL_TRUE - continue handler * - R_FDL_FALSE - exit handler */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ R_FDL_STATIC r_fdl_flag_t R_FDL_Handler_ReactOnFatalErrors (r_fdl_status_t * tmpStat_penu) { r_fdl_flag_t cont; r_fdl_status_t stat; cont = R_FDL_TRUE; /* Check for fatal error (protection or internal error) */ stat = R_FDL_FCUFct_CheckFatalError(); /* Error case */ if (R_FDL_OK != stat) { R_FDL_FCUFct_ClearStatus(); (void)R_FDL_FCUFct_SwitchMode_Start (R_FCU_MODE_USER); /* Switch mode function passed */ if (R_FDL_BUSY == R_FDL_FCUFct_SwitchMode_Check() ) { g_fdl_str.opStatus_enu = R_FDL_OP_END_SYNC_OFF; /* save status, will be returned on mode switch confirmation */ g_fdl_str.opResult_enu = stat; (*tmpStat_penu) = R_FDL_BUSY; } else { (*tmpStat_penu) = stat; } cont = R_FDL_FALSE; } return (cont); } /* R_FDL_Handler_ReactOnFatalErrors */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_Handler_StatusCheckAndSuspendOnReady *********************************************************************************************************************/ /** * Part of the R_FDL_Handler function. * Get and judge Flash operation result (not fatal errors, just operation results) and * do further suspend processing in case of pending suspend request or already suspended * Flash operation. * * @param[out] tmpStat_penu - Status return value. Is set to operation result or to suspended in * case of suspend processing. * @return handler function flow may continue after this function or handler need to exit: * - R_FDL_TRUE - continue handler * - R_FDL_FALSE - exit handler */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ R_FDL_STATIC r_fdl_flag_t R_FDL_Handler_StatusCheckAndSuspendOnReady (r_fdl_status_t * tmpStat_penu) { r_fdl_flag_t cont; r_fdl_status_t res; cont = R_FDL_TRUE; /* Get operation status after operation end and reset the hardware status */ (*tmpStat_penu) = R_FDL_FCUFct_GetStat(); R_FDL_FCUFct_ClearStatus(); /* Suspend handling - suspend possible, part 2 (Flash operation is suspended now) -or- - suspend impossible (operation finished but suspend request still active) */ if (R_FDL_TRUE == g_fdl_str.spdSpdRequest_enu) { /* suspend was impossible --> handle it now after operation completion */ g_fdl_str.spdSpdRequest_enu = R_FDL_FALSE; g_fdl_str.iStat_enu = R_FDL_ISTAT_SUSPEND_PR; } if (R_FDL_ISTAT_SUSPEND_PR == g_fdl_str.iStat_enu) { g_fdl_str.spdResStatus_enu = (*tmpStat_penu); (void)R_FDL_FCUFct_SwitchMode_Start (R_FCU_MODE_USER); res = R_FDL_FCUFct_SwitchMode_Check(); /* Mode already switched */ if (R_FDL_OK == res) { (*tmpStat_penu) = R_FDL_SUSPENDED; /* Backup variables for resume */ g_fdl_str.reqSuspend_pstr = g_fdl_str.reqInt_pstr; g_fdl_str.iStat_enu = R_FDL_ISTAT_SUSPENDED; } /* Wait for mode switch confirmation */ else { (*tmpStat_penu) = R_FDL_BUSY; g_fdl_str.opStatus_enu = R_FDL_OP_SUSPEND_SYNC_OFF; } g_fdl_str.spdMulOp_str.flashAdd_u32 = g_fdl_str.mulOp_str.flashAdd_u32; g_fdl_str.spdMulOp_str.bufAdd_u32 = g_fdl_str.mulOp_str.bufAdd_u32; g_fdl_str.spdMulOp_str.flashAddEnd_u32 = g_fdl_str.mulOp_str.flashAddEnd_u32; g_fdl_str.spdMulOp_str.accessType_enu = g_fdl_str.mulOp_str.accessType_enu; cont = R_FDL_FALSE; } return (cont); } /* R_FDL_Handler_StatusCheckAndSuspendOnReady */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_Handler_MultiOperation *********************************************************************************************************************/ /** * Part of the R_FDL_Handler function. * * In case of multi-operations (erase multiple blocks or write multiple half words), after end * of a single Flash erase/write Flash operation, the next operation is started. * * @param[in, out] tmpStat_penu - current operation status. Used to judge previous operation result * and is updated in case of multi-operation requiring start of new * Flash operation * @return handler function flow may continue after this function or handler need to exit: * - R_FDL_TRUE - continue handler * - R_FDL_FALSE - exit handler */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ R_FDL_STATIC r_fdl_flag_t R_FDL_Handler_MultiOperation (r_fdl_status_t * tmpStat_penu) { r_fdl_flag_t cont; uint32_t cnt; r_fdl_command_t cmd; cont = R_FDL_TRUE; cmd = g_fdl_str.reqInt_pstr->command_enu; /* Check if more data to handle: - erase, write, blank check operation - internal status = OK - more data to erase/write */ if ( (R_FDL_OK == (*tmpStat_penu) ) && (g_fdl_str.mulOp_str.flashAdd_u32 < g_fdl_str.mulOp_str.flashAddEnd_u32) ) { /* Write command starts a new FACI write operation */ #if (defined ENABLE_CMD_WRITE16B) if ( (R_FDL_CMD_WRITE == cmd) || (R_FDL_CMD_WRITE16B == cmd) ) /* PRQA S 0505 */ #else if (R_FDL_CMD_WRITE == cmd) #endif { #if (defined ENABLE_CMD_WRITE16B) if (R_FDL_CMD_WRITE == cmd) { cnt = R_WRITE_SIZE; } else { cnt = R_WRITE_SIZE_16B; } #else cnt = R_WRITE_SIZE; #endif (*tmpStat_penu) = R_FDL_FCUFct_StartWriteOperation (g_fdl_str.mulOp_str.bufAdd_u32, g_fdl_str.mulOp_str.flashAdd_u32, cnt, g_fdl_str.mulOp_str.accessType_enu); g_fdl_str.mulOp_str.flashAdd_u32 += cnt; g_fdl_str.mulOp_str.bufAdd_u32 += cnt; } /* Erase command starts a new FACI erase operation */ else if (R_FDL_CMD_ERASE == cmd) /* PRQA S 0505 */ { (*tmpStat_penu) = R_FDL_FCUFct_StartBCEraseOperation (g_fdl_str.mulOp_str.flashAdd_u32, (g_fdl_str.mulOp_str.flashAdd_u32 + R_BLOCK_SIZE) - 1u, R_FCU_CMD_ERASE, g_fdl_str.mulOp_str.accessType_enu); g_fdl_str.mulOp_str.flashAdd_u32 += R_BLOCK_SIZE; } /* Blank Check command (exceeding 4kB boundary) starts a new FACI blank check operation */ else { cnt = ( (g_fdl_str.mulOp_str.flashAddEnd_u32 + 1uL) - g_fdl_str.mulOp_str.flashAdd_u32); /* Limit count to max */ R_FDL_IFct_CalcFOpUnitCnt_BC (&cnt, g_fdl_str.mulOp_str.flashAdd_u32); (*tmpStat_penu) = R_FDL_FCUFct_StartBCEraseOperation (g_fdl_str.mulOp_str.flashAdd_u32, ( (g_fdl_str.mulOp_str.flashAdd_u32 + cnt) - 1u), R_FCU_CMD_BLANKCHECK, g_fdl_str.mulOp_str.accessType_enu); g_fdl_str.mulOp_str.flashAdd_u32 += cnt; } /* In command execution end (OK or error) */ if (R_FDL_BUSY != (*tmpStat_penu) ) { (void)R_FDL_FCUFct_SwitchMode_Start (R_FCU_MODE_USER); /* Mode already switched */ if (R_FDL_BUSY == R_FDL_FCUFct_SwitchMode_Check() ) { g_fdl_str.opStatus_enu = R_FDL_OP_END_SYNC_OFF; /* save status, will be returned on mode switch confirmation */ g_fdl_str.opResult_enu = (*tmpStat_penu); (*tmpStat_penu) = R_FDL_BUSY; } } cont = R_FDL_FALSE; } return (cont); } /* R_FDL_Handler_MultiOperation */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_Handler_OperationStates *********************************************************************************************************************/ /** * Part of the R_FDL_Handler function. * * This function checks if switch mode is performed. * If yes, it executes different operations depending on internal operation status. * Prepare environment is performed here also. * If not, do nothing * * @param[in, out] tmpStat_penu - current operation status. Used to judge previous operation result * and is updated in case of start of new Flash operation * * @return handler function flow may continue after this function or handler need to exit: * - R_FDL_TRUE - continue handler * - R_FDL_FALSE - exit handler */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ R_FDL_STATIC r_fdl_flag_t R_FDL_Handler_OperationStates (r_fdl_status_t * tmpStat_penu) { r_fdl_flag_t cont; r_fdl_status_t res; cont = R_FDL_TRUE; if ( (R_FDL_OP_IDLE != g_fdl_str.opStatus_enu) && (R_FDL_OP_BUSY != g_fdl_str.opStatus_enu) ) { (*tmpStat_penu) = R_FDL_FCUFct_SwitchMode_Check(); /* Mode switch passed */ if (R_FDL_OK == (*tmpStat_penu) ) { /* Select current operation status */ switch (g_fdl_str.opStatus_enu) { /* Next step after mode switch confirmation for normal operations and prepare */ case R_FDL_OP_EXECUTE_SYNC_ON: { if (R_FDL_CMD_PREPARE_ENV == g_fdl_str.reqInt_pstr->command_enu) { res = R_FDL_FCUFct_ForcedStop(); (void)R_FDL_FCUFct_SwitchMode_Start (R_FCU_MODE_USER); /* No timeout during forced stop processing */ if (R_FDL_OK == res) { g_fdl_str.opStatus_enu = R_FDL_OP_PREPARE_START; } else { g_fdl_str.opStatus_enu = R_FDL_OP_END_SYNC_OFF; g_fdl_str.opResult_enu = R_FDL_ERR_INTERNAL; } cont = R_FDL_FALSE; (*tmpStat_penu) = R_FDL_BUSY; } else { cont = R_FDL_UFct_FlashOpStart (g_fdl_str.reqInt_pstr, tmpStat_penu, R_FDL_FALSE); } break; } /* Prepare operation 1st state */ case R_FDL_OP_PREPARE_START: { /* Disable FCU error interrupt which will occur always during FCU initialization from power up */ R_FDL_FCUFct_Switch_FAEINT (R_FDL_FALSE); /* Initialize the FCU code RAM */ (*tmpStat_penu) = R_FDL_FCUFct_InitRAM(); /* No timeout error during RAM initialization */ if (R_FDL_OK == (*tmpStat_penu) ) { (*tmpStat_penu) = R_FDL_FCUFct_SwitchMode_Start (R_FCU_MODE_PE); /* No protection error during mode switch */ if (R_FDL_OK == (*tmpStat_penu) ) { (*tmpStat_penu) = R_FDL_BUSY; g_fdl_str.opStatus_enu = R_FDL_OP_PREPARE_RST_FCU; } } /* In error case we need to activate the FAEINT again as the operation will immediately finish */ if (R_FDL_BUSY != (*tmpStat_penu) ) { R_FDL_FCUFct_Switch_FAEINT (R_FDL_TRUE); } cont = R_FDL_FALSE; break; } /* Prepare operation 2nd state */ case R_FDL_OP_PREPARE_RST_FCU: { /* Reset FCU again to clear any possible ECC errors */ res = R_FDL_FCUFct_ForcedStop(); R_FDL_FCUFct_ClearStatus(); (void)R_FDL_FCUFct_SwitchMode_Start (R_FCU_MODE_USER); /* Enable FCU error interrupt again, now we expect no more ECC error */ R_FDL_FCUFct_Switch_FAEINT (R_FDL_TRUE); /* No timeout during forced stop processing */ if (R_FDL_OK == res) { g_fdl_str.opStatus_enu = R_FDL_OP_PREPARE_END; } else { g_fdl_str.opStatus_enu = R_FDL_OP_END_SYNC_OFF; g_fdl_str.opResult_enu = R_FDL_ERR_INTERNAL; } (*tmpStat_penu) = R_FDL_BUSY; cont = R_FDL_FALSE; break; } /* Prepare operation 3rd state */ case R_FDL_OP_PREPARE_END: { (*tmpStat_penu) = R_FDL_FCUFct_VerifyChecksum(); /* Checksum check passed */ if (R_FDL_BUSY == (*tmpStat_penu) ) { (*tmpStat_penu) = R_FDL_FCUFct_GetDFSize (&(g_fdl_str.dfSize_u32) ); #ifdef R_FDL_F1L_PATCH_DF_OVERSIZE g_fdl_str.dfSize_u32 *= 2uL; #endif if (R_FDL_OK == (*tmpStat_penu) ) { /* FDL pool size does not exceed Data FLash size */ if (g_fdl_str.RTCfg_pstr->fdlPoolSize_u16 <= (g_fdl_str.dfSize_u32 >> R_BLOCK_SIZE_2N) ) { /* Configure the FCU frequency */ (*tmpStat_penu) = R_FDL_FCUFct_SetFrequency(); } else { (*tmpStat_penu) = R_FDL_ERR_CONFIGURATION; } } } if (R_FDL_OK == (*tmpStat_penu) ) { g_fdl_str.iStat_enu = R_FDL_ISTAT_NORMALOP; } cont = R_FDL_FALSE; break; } /* Resume command execution (FACI resume) */ case R_FDL_OP_RESUME_SYNC_ON: { R_FDL_FCUFct_Resume(); g_fdl_str.opStatus_enu = R_FDL_OP_BUSY; (*tmpStat_penu) = R_FDL_BUSY; break; } /* Resume command execution (Start new operation) */ case R_FDL_OP_RESUME_MULTI_SYNC_ON: { g_fdl_str.opStatus_enu = R_FDL_OP_BUSY; (*tmpStat_penu) = R_FDL_BUSY; break; } /* Command execution end */ case R_FDL_OP_END_SYNC_OFF: { g_fdl_str.opStatus_enu = R_FDL_OP_IDLE; (*tmpStat_penu) = g_fdl_str.opResult_enu; cont = R_FDL_FALSE; break; } /* suspend processing end */ case R_FDL_OP_SUSPEND_SYNC_OFF: { (*tmpStat_penu) = R_FDL_SUSPENDED; /* Backup variables for resume */ g_fdl_str.reqSuspend_pstr = g_fdl_str.reqInt_pstr; g_fdl_str.iStat_enu = R_FDL_ISTAT_SUSPENDED; cont = R_FDL_FALSE; break; } default: { /* Nothing to do */ break; } } /* switch */ } else { cont = R_FDL_FALSE; } } return (cont); } /* R_FDL_Handler_OperationStates */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_Handler *********************************************************************************************************************/ /** * User interface function: * This function forwards an initiated Flash operation until it is finished. At operation end the * result is set in the request structure. * After initiation by R_FDL_Execute, the function R_FDL_Handler need to be called regularly to finish * the operation. * @param[in,out] - * @return --- * * The function returns the operation result in the status variable, passed to * the R_FDL_Execute variable (request.status_enu) */ /*********************************************************************************************************************/ /********************************************************************************************************************* * MISRA Rule: MISRA-C 2004 rule 1.2 (QAC message 0505) * Reason: QAC claims referencing a possibly undefined pointer. * Verification: Reviewed, that this is not possible. The pointer is always defined *********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ void R_FDL_Handler (void) /* PRQA S 1503 */ { r_fdl_flag_t contHdrFct; r_fdl_status_t tmpStatus; r_fdl_status_t res; tmpStatus = R_FDL_BUSY; /* Check if the handler has something to do, block on not initialized library and on StandBy processing */ if ( (R_FDL_TRUE == R_FDL_UFct_StateNotStandBy() ) && ( (R_FDL_REQUEST_POINTER_UNDEFINED != g_fdl_str.reqInt_pstr) || (R_FDL_TRUE == g_fdl_str.spdResRequest_enu) || (R_FDL_TRUE == g_fdl_str.cancelRequest_enu) ) ) { /* Cancel Request management */ contHdrFct = R_FDL_Handler_CancelReq (&tmpStatus); /* continue handler execution: Suspend handling (suspend possible, part 1)*/ if (R_FDL_TRUE == contHdrFct) { contHdrFct = R_FDL_Handler_BusyAndSuspendPossible(); } /* continue handler execution: Resume handling */ if (R_FDL_TRUE == contHdrFct) { contHdrFct = R_FDL_Handler_ChkResume (&tmpStatus); } /* continue handler execution: command processing execution */ if (R_FDL_TRUE == contHdrFct) { contHdrFct = R_FDL_Handler_OperationStates (&tmpStatus); } /* continue handler execution: check if the FCU is busy */ if (R_FDL_TRUE == contHdrFct) { contHdrFct = R_FDL_FCUFct_ChkReady(); } /* continue handler execution: Fatal error evaluation */ if (R_FDL_TRUE == contHdrFct) { contHdrFct = R_FDL_Handler_ReactOnFatalErrors (&tmpStatus); } /* continue handler execution: judge operation status and do suspend handling part 2 */ if (R_FDL_TRUE == contHdrFct) { contHdrFct = R_FDL_Handler_StatusCheckAndSuspendOnReady (&tmpStatus); } /* continue handler execution: multi operation (Write/Erase) state machine */ if (R_FDL_TRUE == contHdrFct) { contHdrFct = R_FDL_Handler_MultiOperation (&tmpStatus); } /* continue handler execution: normal operation end */ if (R_FDL_TRUE == contHdrFct) { (void)R_FDL_FCUFct_SwitchMode_Start (R_FCU_MODE_USER); res = R_FDL_FCUFct_SwitchMode_Check(); if (R_FDL_BUSY == res) { g_fdl_str.opStatus_enu = R_FDL_OP_END_SYNC_OFF; /* save status, will be returned on mode switch confirmation */ g_fdl_str.opResult_enu = tmpStatus; tmpStatus = R_FDL_BUSY; } } /* Operation end, return status to user */ if (R_FDL_BUSY != tmpStatus) { R_FDL_UFct_EndCurrentOperation (tmpStatus); } #ifdef PATCH_TO_SIMULATE_ERRORS tstData_str.simCntHdr_u32++; #endif } } /* R_FDL_Handler */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_GetVersionString *********************************************************************************************************************/ /** * User interface function: * Returns the pointer to the library version string, stores in the library code section. * * @param[in,out] - * @return Pointer to the version string in Flash */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_CONST #include "r_fdl_mem_map.h" /* PRQA S 5087 */ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ const uint8_t *R_FDL_GetVersionString (void) /* PRQA S 1503 */ { static const uint8_t r_fdl_vStr[] = R_FDL_VERSION_STRING; return (&r_fdl_vStr[0]); } #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ #define R_FDL_STOP_SEC_CONST #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_SuspendRequest *********************************************************************************************************************/ /** * User interface function: * Sets the suspend request flag for the write or erase operation * * Note: * The operation is not immediately suspended. Suspend handling is controlled by R_FDL_Handler. * The suspend status is returned by the status variable of the request structure (Set in * R_FDL_Handler). * * Suspend request handling: * - Reject if * - we have no active Flash operation * - we have already a Flash operation suspended * - we have a cancel request * - Reset resume request if set (then we have a not yet handled resume request) * - Set suspend request if we have an operation ongoing and we are not already in suspend * processing * * @param[in,out] - * @return result of the suspend request * - R_FDL_OK - Request accepted * - R_FDL_ERR_REJECTED - Request rejected */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ r_fdl_status_t R_FDL_SuspendRequest (void) /* PRQA S 1503 */ { r_fdl_status_t ret; ret = R_FDL_ERR_REJECTED; /* Block on: - not initialized library - StandBy processing */ if (R_FDL_TRUE == R_FDL_UFct_StateNotStandBy() ) { /* Set the request flag only if we are busy and not in suspend state or suspend processing */ if ( (R_FDL_REQUEST_POINTER_UNDEFINED != g_fdl_str.reqInt_pstr) && (R_FDL_REQUEST_POINTER_UNDEFINED == g_fdl_str.reqSuspend_pstr) && (R_FDL_ISTAT_NORMALOP == g_fdl_str.iStat_enu) && (R_FDL_FALSE == g_fdl_str.cancelRequest_enu) ) { ret = R_FDL_OK; g_fdl_str.spdSpdRequest_enu = R_FDL_TRUE; } } return (ret); } /* R_FDL_SuspendRequest */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_ResumeRequest *********************************************************************************************************************/ /** * User interface function: * Sets the resume request flag for the write or erase operation * * Note: * The operation is not immediately resumed. Resume handling is controlled by R_FDL_Handler. * The status is returned by the status variable of the request structure (Set in * R_FDL_Handler). * * Resume request handling: * - Reset suspend request if set (then we have a not yet handled suspend request) * - Set resume request if we have a suspended operation (reqSuspend_pstr defined) * and we have not already a resume request * - Reject all other conditions * * @param[in,out] - * @return result of the resume request * - R_FDL_OK - Request accepted * - R_FDL_ERR_REJECTED - Request rejected */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ r_fdl_status_t R_FDL_ResumeRequest (void) /* PRQA S 1503 */ { r_fdl_status_t ret; ret = R_FDL_OK; /* Block on not initialized library and on StandBy processing */ if (R_FDL_TRUE == R_FDL_UFct_StateNotStandBy() ) { /* Set the request flag only if we are already suspended */ if ( (R_FDL_ISTAT_SUSPENDED == g_fdl_str.iStat_enu) && (R_FDL_FALSE == g_fdl_str.cancelRequest_enu) ) { g_fdl_str.spdResRequest_enu = R_FDL_TRUE; } else { ret = R_FDL_ERR_REJECTED; } } else { ret = R_FDL_ERR_REJECTED; } return (ret); } /* R_FDL_ResumeRequest */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_Standby *********************************************************************************************************************/ /** * User interface function: * Prepares the HW for fast standby entry: * - on write end erase * - blank check is not suspendable, here the function is without effect * * This function can be called asynchronous (e.g. interrupt function) and so need to take * care of the current hardware status in order to restore it later on during wakeup * * Note: * the function need to be called continuously until the result is != R_FDL_BUSY * * @param[in,out] - * @return result of the standby operation * - R_FDL_OK - Flash hardware is in standby or ready (no more Flash operation) * - R_FDL_BUSY - Flash hardware is still busy. Repeat calling the function * - R_FDL_ERR_REJECTED - Rejected, as the library is not initialized */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ r_fdl_status_t R_FDL_StandBy (void) /* PRQA S 1503 */ { r_fdl_status_t ret; /* Allow execution in each initialized state except StandBy and Init */ if ( ( (R_FDL_TRUE == R_FDL_UFct_StateNotStandBy() ) && (R_FDL_ISTAT_INIT != g_fdl_str.iStat_enu) ) || (R_FDL_ISTAT_STANDBY_PR == g_fdl_str.iStat_enu) ) { /* On Standby processing start, backup the internal Status */ if (R_FDL_ISTAT_STANDBY_PR != g_fdl_str.iStat_enu) { g_fdl_str.stByIStatBackUp_enu = g_fdl_str.iStat_enu; /* Set to standby processing. By that, other EEL operations are blocked */ g_fdl_str.iStat_enu = R_FDL_ISTAT_STANDBY_PR; } /* only operate standby, if any Flash operation is ongoing */ if (R_FDL_FALSE == R_FDL_FCUFct_ChkReady() ) { /* hardware is still busy */ ret = R_FDL_BUSY; /* only operate standby if the Flash operation is suspendable additionally check if we are not already suspended or in suspend processing */ if (R_FDL_TRUE == R_FDL_FCUFct_ChkSuspendable() ) { R_FDL_FCUFct_Suspend(); } } /* hardware is no longer busy, set library into standby */ else { g_fdl_str.iStat_enu = R_FDL_ISTAT_STANDBY; ret = R_FDL_OK; } } else { /* library is not initialized */ ret = R_FDL_ERR_REJECTED; } return (ret); } /* R_FDL_StandBy */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_WakeUp *********************************************************************************************************************/ /** * User interface function: * Wake up the hardware from standby * * @param[in,out] - * @return result of the initialization check * - R_FDL_OK - Wakeup succeeded * - R_FDL_ERR_REJECTED - Rejected, as the library is not initialized */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ r_fdl_status_t R_FDL_WakeUp (void) /* PRQA S 1503 */ { r_fdl_status_t ret; /* We can only wakeup if we have been in standby before */ if (R_FDL_ISTAT_STANDBY == g_fdl_str.iStat_enu) { ret = R_FDL_OK; g_fdl_str.iStat_enu = g_fdl_str.stByIStatBackUp_enu; /* check if we need to wakeup */ if (R_FDL_TRUE == R_FDL_FCUFct_ResumeChkNeed() ) { R_FDL_FCUFct_Resume(); } } else { ret = R_FDL_ERR_REJECTED; } return (ret); } /* R_FDL_WakeUp */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_CancelRequest *********************************************************************************************************************/ /** * User interface function: * Sets the cancel request flag for an ongoing operation (exception Prepare environment cmd) * * Note: * The operation is not immediately cancelled. Cancel handling is controlled by R_FDL_Handler. * The status is returned by the status variable of the request structure (Set in * R_FDL_Handler). * * Cancel request handling: * - Set cancel request if we do not have a standby operation * and we have not already a cancel request * - Reject all other conditions * * @param[in,out] - * @return result of the cancel request * - R_FDL_OK - Request accepted * - R_FDL_ERR_REJECTED - Request rejected */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ r_fdl_status_t R_FDL_CancelRequest (void) /* PRQA S 1503 */ { r_fdl_status_t ret; ret = R_FDL_OK; /* Block on not initialized library and on StandBy processing */ if ( (R_FDL_TRUE == R_FDL_UFct_StateNotStandBy() ) && (R_FDL_ISTAT_INIT != g_fdl_str.iStat_enu) && (R_FDL_FALSE == g_fdl_str.cancelRequest_enu) ) { /* Library is in suspended state, no operation on-going */ if ( (R_FDL_ISTAT_SUSPENDED == g_fdl_str.iStat_enu) && (R_FDL_REQUEST_POINTER_UNDEFINED == g_fdl_str.reqInt_pstr) ) { ret = R_FDL_FCUFct_SwitchMode_Start (R_FCU_MODE_PE); } /* No operation ongoing */ else if ( (R_FDL_ISTAT_NORMALOP == g_fdl_str.iStat_enu) && (R_FDL_REQUEST_POINTER_UNDEFINED == g_fdl_str.reqInt_pstr) ) { ret = R_FDL_ERR_REJECTED; } else { /* Nothing to do, added to fix QAC warning message 2004 */ } /* All conditions fulfilled for cancel */ if (R_FDL_OK == ret) { g_fdl_str.cancelRequest_enu = R_FDL_TRUE; } } else { ret = R_FDL_ERR_REJECTED; } return (ret); } /* R_FDL_CancelRequest */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_UFct_FlashOpStart *********************************************************************************************************************/ /** * Extract information required for a Flash operation and call the function which starts the operation. * * @param[in] request_pstr - pointer to the operation request structure * @param[out] tmpStat_penu - Status return value. Is set to operation result. Possible values: * - R_FDL_BUSY * - R_FDL_ERR_PARAMETER * - R_FDL_ERR_PROTECTION * - R_FDL_OK (Read operation) * - R_FDL_ERR_ECC_SED (Read operation) * - R_FDL_ERR_ECC_DED (Read operation) * @param[in] isCalledFromExecute_enu - flag to distinguish if the function is called from: * - R_FDL_Execute: value R_FDL_TRUE * - R_FDL_Handler: value R_FDL_FALSE * * @return handler function flow may continue after this function or handler need to exit: * - R_FDL_TRUE - continue handler * - R_FDL_FALSE - exit handler * In case the function is called from R_FDL_Execute, the return value can be ignored. */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ R_FDL_STATIC r_fdl_flag_t R_FDL_UFct_FlashOpStart (r_fdl_request_t * request_pstr, r_fdl_status_t * tmpStat_penu, r_fdl_flag_t isCalledFromExecute_enu) { uint32_t addFlash; uint32_t cntTotal; uint32_t addBuf; uint32_t granularityCurOp; uint32_t cntCurOp; uint32_t addEndCurOp; r_fdl_command_t cmd; r_fdl_accessType_t accType; r_fdl_flag_t cont; uint8_t fcuCmd; addFlash = (request_pstr->idx_u32); cntTotal = (request_pstr->cnt_u16); cmd = (request_pstr->command_enu); accType = (request_pstr->accessType_enu); addBuf = (request_pstr->bufAddr_u32); /* granularityCurOp has the default value for all commands except WRITE_16B */ granularityCurOp = R_WRITE_SIZE; cont = R_FDL_TRUE; (*tmpStat_penu) = R_FDL_BUSY; if (R_FDL_CMD_ERASE == cmd) { addFlash <<= R_BLOCK_SIZE_2N; cntTotal <<= R_BLOCK_SIZE_2N; /* granularityCurOp has the default value */ cntCurOp = (1 << R_BLOCK_SIZE_2N); /* Set buffer address to a valid address */ addBuf = 0x00000001uL; fcuCmd = R_FCU_CMD_ERASE; } else if (R_FDL_CMD_BLANKCHECK == cmd) { cntTotal *= R_WRITE_SIZE; cntCurOp = cntTotal; /* Limit count to max */ R_FDL_IFct_CalcFOpUnitCnt_BC (&cntCurOp, addFlash); /* Set buffer address to a valid address */ addBuf = 0x00000001uL; fcuCmd = R_FCU_CMD_BLANKCHECK; } /* write 4 bytes (1 words) at once */ else if (R_FDL_CMD_WRITE == cmd) { cntCurOp = R_WRITE_SIZE; cntTotal *= R_WRITE_SIZE; fcuCmd = R_FCU_CMD_WRITE; } #if (defined ENABLE_CMD_WRITE16B) /* write 16 bytes (4 words) at once */ else if (R_FDL_CMD_WRITE16B == cmd) { cntCurOp = R_WRITE_SIZE_16B; cntTotal *= R_WRITE_SIZE_16B; granularityCurOp = cntCurOp; fcuCmd = R_FCU_CMD_WRITE; } #endif /* Read command */ else { cntTotal *= R_WRITE_SIZE; cntCurOp = cntTotal; /* for the read cmd there is not equivalent FCU cmd, it is initialized here to fix QAC error message */ fcuCmd = 0x00; } addEndCurOp = (addFlash + cntCurOp) - 1uL; /* Check against invalid buffer address (R_FDL_CMD_WRITE, R_FDL_CMD_WRITE16B, R_FDL_CMD_READ) - Only if function is called by R_FDL_Execute */ if (R_FDL_TRUE == isCalledFromExecute_enu) { if (R_FDL_NULL == addBuf) { (*tmpStat_penu) = R_FDL_ERR_PARAMETER; } else { (*tmpStat_penu) = R_FDL_IFct_ChkAccessBoundaries (addFlash, cntTotal, accType, granularityCurOp); } /* Reset flag; it is updated later on in case the switch mode to PE is performed correctly */ cont = R_FDL_FALSE; } if (R_FDL_BUSY == (*tmpStat_penu) ) { /* Read command is treated only in R_FDL_Execute, no need to check given parameter isCalledFromExecute_enu */ if (R_FDL_CMD_READ == cmd) { /* user destination buffer must be 4 bytes aligned */ if (0 == (addBuf & R_U32_ALIGNED) ) { (*tmpStat_penu) = R_FDL_FCUFct_ReadOperation ( (volatile uint32_t *)(&addFlash), addBuf, (cntTotal / R_WRITE_SIZE) ); request_pstr->idx_u32 = addFlash; /* Store possible fail address to request structure */ } else { (*tmpStat_penu) = R_FDL_ERR_PARAMETER; } } /* all commands except Read */ else { /* Switch mode only required once */ if (R_FDL_TRUE == isCalledFromExecute_enu) { (*tmpStat_penu) = R_FDL_FCUFct_SwitchMode_Start (R_FCU_MODE_PE); if (R_FDL_OK == (*tmpStat_penu) ) { (*tmpStat_penu) = R_FDL_FCUFct_SwitchMode_Check(); if (R_FDL_OK == (*tmpStat_penu) ) { cont = R_FDL_TRUE; } else { g_fdl_str.opStatus_enu = R_FDL_OP_EXECUTE_SYNC_ON; } } } /* continue if mode switch passed (either immediately after the mode switch start or if the function is later on called by the handler */ if (R_FDL_TRUE == cont) { if ( (R_FDL_CMD_ERASE == cmd) || (R_FDL_CMD_BLANKCHECK == cmd) ) { (*tmpStat_penu) = R_FDL_FCUFct_StartBCEraseOperation (addFlash, addEndCurOp, fcuCmd, accType); } /* Write command */ else { (*tmpStat_penu) = R_FDL_FCUFct_StartWriteOperation (addBuf, addFlash, cntCurOp, accType); g_fdl_str.mulOp_str.bufAdd_u32 = addBuf + cntCurOp; /* Next Source Address */ } /* command can be executed */ if (R_FDL_BUSY == (*tmpStat_penu) ) { g_fdl_str.opStatus_enu = R_FDL_OP_BUSY; /* Prepare for multi-word write */ g_fdl_str.mulOp_str.flashAdd_u32 = addEndCurOp + 1uL; g_fdl_str.mulOp_str.flashAddEnd_u32 = (addFlash + cntTotal) - 1uL; /* Source End Address */ g_fdl_str.mulOp_str.accessType_enu = accType; } /* error --> switch back to user mode */ else { (void)R_FDL_FCUFct_SwitchMode_Start (R_FCU_MODE_USER); /* save operation status and return it after switch mode confirmation */ g_fdl_str.opResult_enu = (*tmpStat_penu); g_fdl_str.opStatus_enu = R_FDL_OP_END_SYNC_OFF; cont = R_FDL_FALSE; (*tmpStat_penu) = R_FDL_BUSY; } } } } return (cont); } /* R_FDL_UFct_FlashOpStart */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_UFct_EndCurrentOperation *********************************************************************************************************************/ /** * At the end of a Flash operation, this function updates the request structure elements and * resets the library internal pointer to this structure. * * @param[in] ret_enu - status return value * @return --- * * The function modifies the global structure g_fdl_str.reqInt_pstr to set the operation * status */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ R_FDL_STATIC void R_FDL_UFct_EndCurrentOperation (r_fdl_status_t ret_enu) { (g_fdl_str.reqInt_pstr)->status_enu = ret_enu; /* For Blank Check, return fail address too */ if ( (R_FDL_CMD_BLANKCHECK == (g_fdl_str.reqInt_pstr)->command_enu) && (R_FDL_ERR_BLANKCHECK == ret_enu) ) { (g_fdl_str.reqInt_pstr)->idx_u32 = g_fdl_str.opFailAddr_u32; } (g_fdl_str.reqInt_pstr)->accessType_enu = R_FDL_ACCESS_NONE; (g_fdl_str.reqInt_pstr) = R_FDL_REQUEST_POINTER_UNDEFINED; g_fdl_str.opStatus_enu = R_FDL_OP_IDLE; /* In case of internal error enforce re-initialization. No more command execution will be allowed */ if (R_FDL_ERR_INTERNAL == ret_enu) { g_fdl_str.iStat_enu = R_FDL_ISTAT_NOINIT; } } /* R_FDL_UFct_EndCurrentOperation */ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /********************************************************************************************************************* * Function name: R_FDL_UFct_StateNotStandBy *********************************************************************************************************************/ /** * Check if the library is initialized and not in StandBy or StandBy processing * * @param[in,out] - * @return - R_FDL_TRUE Library is initialized * - R_FDL_FALSE Library is not initialized */ /*********************************************************************************************************************/ #define R_FDL_START_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ R_FDL_STATIC r_fdl_flag_t R_FDL_UFct_StateNotStandBy (void) { r_fdl_flag_t ret; /* Any states except StandBy related states or uninitialized state */ if ( (R_FDL_ISTAT_NORMALOP == g_fdl_str.iStat_enu) || (R_FDL_ISTAT_INIT == g_fdl_str.iStat_enu) || ( (R_FDL_ISTAT_SUSPEND_PR == g_fdl_str.iStat_enu) || (R_FDL_ISTAT_SUSPENDED == g_fdl_str.iStat_enu) ) ) { ret = R_FDL_TRUE; } /* StandBy related state or uninitialized state */ else { ret = R_FDL_FALSE; } return (ret); } /* R_FDL_UFct_StateNotStandBy */ /*********************************************************************************************************************/ #define R_FDL_STOP_SEC_PUBLIC_CODE #include "r_fdl_mem_map.h" /* PRQA S 5087 */ /*********************************************************************************************************************/