/*********************************************************************************************************************** * FILE DESCRIPTION * ------------------------------------------------------------------------------------------------------------------*/ /** \file * \brief Library containing common functionality for memory programming: * - Erase of memory region * - Data processing (e.g. decryption and decompression) * - Segmentation and alignment * - Signature / checksum verification over RAM contents * - Pipelined programming * * Used by OEM dependent diagnostics to program incoming download data. * * -------------------------------------------------------------------------------------------------------------------- * COPYRIGHT * -------------------------------------------------------------------------------------------------------------------- * \par Copyright * \verbatim * Copyright (c) 2025 by Vector Informatik GmbH. All rights reserved. * * This software is copyright protected and proprietary to Vector Informatik GmbH. * Vector Informatik GmbH grants to you only those rights as set out in the license conditions. * All other rights remain with Vector Informatik GmbH. * \endverbatim */ /**********************************************************************************************************************/ /*********************************************************************************************************************** * REVISION HISTORY * -------------------------------------------------------------------------------------------------------------------- * Version Date Author Change Id Description * -------------------------------------------------------------------------------------------------------------------- * 01.00.00 2012-03-23 visjhg - Initial release * 01.00.01 2012-03-26 visjhg - Added description to file header * 01.01.00 2012-04-05 visjhg ESCAN00057963 No changes * Changes and optimizations after code review * 01.02.00 2012-04-27 visjhg ESCAN00058452 Added support for processed length * ESCAN00058453 Removed fbl_mem_cfg.h include * ESCAN00058621 No changes * 01.03.00 2012-06-22 visjhg ESCAN00059475 No changes * ESCAN00059477 No changes * 01.04.00 2013-02-01 visjhg ESCAN00064290 Extensions for multi processor systems (pass-through) * Rework of block start indication interface * Pass additional info in structure * visjhg ESCAN00064292 Added block erase * visjhg ESCAN00064296 Preamble length switchable at runtime * visjhg ESCAN00064301 Added signature verification on ROM contents * Rework of block verify interface * Keep track of segment history (structure provided externally) * visjhg - Added additional error codes for new functionality * visjhg ESCAN00061335 No changes * visjhg ESCAN00064333 No changes * visjhg ESCAN00061764 No changes * visjhg ESCAN00061814 No changes * visjhg ESCAN00064338 Added post handler for SegmentEndIndication * visach ESCAN00062919 Adapted comments to use Doxygen * visjhg ESCAN00064334 Added interface to remap error codes to OEM dependent value * visjhg ESCAN00064339 Segmented data processing: data produced during one cycle may be * smaller than buffer size * visjhg ESCAN00064330 Explicit resume of suspended operation * Added state "suspend pending" * Added active operation check * visjhg ESCAN00064343 Added support for multiple input sources * visjhg - Added additional error codes for new functionality * visjhg - Additional integration time checks * visjhg ESCAN00064543 No changes * visjhg ESCAN00064720 Replaced __ApplFblMemCheckDfi by __ApplFblMemIsDataProcessingRequired * 01.05.00 2013-04-10 visjhg ESCAN00064871 No changes * visjhg ESCAN00064890 No changes * visjhg - No changes * visjhg ESCAN00065830 No changes * visjhg ESCAN00066375 No changes * visjhg ESCAN00066377 Encapsulate erase functionality * visjhg ESCAN00066379 Added interface version compatibility check * visjhg ESCAN00066380 Exported FblMemInit * 01.06.00 2013-07-22 visase ESCAN00066743 No changes * visjhg ESCAN00067433 Added FblMemDeinit * Updated interface version * visjhg ESCAN00068321 Force response pending for erase operation * visjhg ESCAN00069161 Added pipelined verification * Rework of block start and verify interface * Changed verification configuration options and error codes * Updated interface version (incompatible changes) * visjhg ESCAN00069190 No changes * 01.07.00 2013-08-16 visjhg ESCAN00069507 No changes * visjhg ESCAN00069803 Updated interface version (enable/disable verification at run-time) * ESCAN00069781 No changes * ESCAN00069797 No changes * visjhg ESCAN00069843 No changes * 02.00.00 2013-12-12 visjhg ESCAN00069945 No changes * visjhg ESCAN00072568 Error / status for BlockStartVerifyInit replaced by SegmentStartVerifyInit * visjhg ESCAN00071344 No changes * visjhg ESCAN00072569 Raised major version to match API version * visjhg ESCAN00072156 No changes * visjhg ESCAN00072570 No changes * visjhg ESCAN00072631 No changes * 02.01.00 2014-03-12 visjhg ESCAN00073504 Changed signature of input verification function type * visjhg ESCAN00074066 No changes * 02.02.00 2014-05-09 visjhg ESCAN00075225 No changes * visjhg - Removed some integration time checks * 03.00.00 2015-03-03 visjhg - Changed compatibility remapping for extended status (SegmentStartVerifyInit) * visjhg ESCAN00076591 Updated interface version (support for external stream output) * visjhg ESCAN00077689 No changes * visjhg ESCAN00077891 No changes * visjhg ESCAN00081491 Added support for resumable programming * visjhg ESCAN00081494 Added support for verification on processed input data * visjhg ESCAN00081493 Added selective pipelined programming (forced flush when disabled) * 03.01.00 2015-04-23 visjhg ESCAN00082572 No changes * visjhg ESCAN00082605 Added support for reporting of progress information * visjhg ESCAN00082606 Added support for gap fill (requires ordered segments) * 03.01.01 2015-04-27 visjhg ESCAN00082700 No changes * 03.01.02 2015-05-27 visjhg ESCAN00083138 No changes * 03.01.03 2015-06-13 visjhg ESCAN00083358 No changes * visjhg ESCAN00083390 No changes * visjhg ESCAN00083391 No changes * visjhg ESCAN00083392 Updated interface version * 03.02.00 2015-07-21 visjhg ESCAN00084101 No changes * visjhg ESCAN00084102 Added parameter type structure for stream processing * 03.02.01 2015-08-19 visjhg ESCAN00084279 No changes * visjhg ESCAN00084559 No changes * visjhg ESCAN00084560 No changes * 03.02.02 2015-09-04 visjhg ESCAN00084994 No changes * 04.00.00 2015-09-17 visjhg ESCAN00085249 Support combination of input and processed verification * Updated interface version * visjhg ESCAN00085250 No changes * visjhg ESCAN00085251 No changes * 04.01.00 2016-04-01 visjhg ESCAN00087997 Updated interface version * visjhg ESCAN00088935 No changes * 04.02.00 2016-10-06 visjhg ESCAN00090120 No changes * vishrf ESCAN00091253 No changes * 04.02.01 2017-05-31 visjhg ESCAN00094695 No changes * visjhg ESCAN00095201 No changes * visjhg ESCAN00095356 No changes * visjhg - Updated interface version * 04.03.00 2017-07-26 visjhg ESCAN00095772 No changes * visjhg ESCAN00095774 Added FblMemFlushInputData * Updated interface version * visjhg ESCAN00095683 Place FblMemResumeIndication in RAMCODE section * visjhg ESCAN00096075 No changes * 04.03.01 2017-08-07 visjhg ESCAN00096209 No changes * 04.04.00 2018-08-22 visjhg ESCAN00100464 No changes * visjhg ESCAN00097115 No changes * visjhg ESCAN00100482 Updated interface version (addition of __ApplFblMemConditionCheck) * 04.04.01 2018-09-25 visjhg ESCAN00100850 Updated interface version (preamble for MCMP download use-case) * 04.05.00 2018-11-30 visjhg ESCAN00101500 Added custom error codes to tFblMemStatus * Updated interface version * 04.05.01 2019-01-23 visjhg ESCAN00101568 No changes * 04.05.02 2019-08-20 vistbe ESCAN00103967 Updated interface version * 04.05.03 2019-10-02 visrie ESCAN00104203 Fixed resumable pipelined verification * 04.06.00 2019-10-29 vistmo FBL-813 Migration to MISRA 2012 * 04.06.01 2020-03-18 visrie ESCAN00105683 No changes * 04.06.02 2020-05-11 visjdn ESCAN00105967 No changes * 04.06.03 2020-07-03 vistmo ESCAN00106050 No changes * 04.07.00 2021-04-12 lhopfhauer FBL-2187 Added/adapted MemMap sections * 04.08.00 2021-06-11 visjdn FBL-3560 Add support for more than 256 download segments * 04.09.00 2021-07-09 lhopfhauer FBL-3442 Add option to avoid abortion of verification procedure in case of error * Updated MISRA justifications * 04.09.01 2021-11-05 lhopfhauer ESCAN00110663 No changes * 04.10.00 2022-05-02 lhopfhauer FBL-5067 No changes * 04.10.01 2022-08-03 fmenke ESCAN00112185 No changes * 04.10.02 2023-05-08 lhopfhauer ESCAN00114573 No changes * 04.11.00 2023-08-04 visrie FBL-5709 No changes * 04.12.00 2023-09-04 vistmo FBL-7572 Allow processed verification in combination with stream output * 04.12.01 2024-02-02 lhopfhauer ESCAN00116407 Out of bounds write access * ESCAN00116408 Resume may not work * ESCAN00116457 No changes * 04.13.00 2025-09-16 pharring FBL-10120 Add support for FblLib_Logger * 04.13.01 2025-11-07 aeller ESCAN00121551 No changes * ESCAN00121700 No changes * 04.14.00 2025-11-25 fmenke FBL-11808 No changes **********************************************************************************************************************/ #ifndef FBL_MEM_H #define FBL_MEM_H /*********************************************************************************************************************** * VERSION **********************************************************************************************************************/ /* ##V_CFG_MANAGEMENT ##CQProject : FblLib_Mem CQComponent : Implementation */ #define FBLLIB_MEM_VERSION 0x0414u #define FBLLIB_MEM_RELEASE_VERSION 0x00u /* Interface version */ /** Major interface version identifies incompatible changes */ #define FBL_MEM_API_VERSION_MAJOR 0x04u /** Minor interface version identifies backward compatible changes */ #define FBL_MEM_API_VERSION_MINOR 0x07u /** Release interface version identifies cosmetic changes */ #define FBL_MEM_API_VERSION_RELEASE 0x00u /*********************************************************************************************************************** * INCLUDES **********************************************************************************************************************/ #include "fbl_mem_oem.h" /*********************************************************************************************************************** * DEFINES **********************************************************************************************************************/ /* FblLib_Logger defines */ /** Check for pending operations Enter task on states "pending", "suspend pending" and "suspended" Condition equals ( (fblMemProgState == kFblMemProgState_Pending) || (fblMemProgState == kFblMemProgState_Checkpoint) || (fblMemProgState == kFblMemProgState_SuspendPending) || (fblMemProgState == kFblMemProgState_Suspended) ) */ #define FblMemTaskIsPending() (fblMemProgState >= kFblMemProgState_Suspended) /** Check for active operations Condition equals ( (fblMemProgState == kFblMemProgState_Pending) || (fblMemProgState == kFblMemProgState_Checkpoint) || (fblMemProgState == kFblMemProgState_SuspendPending) ) */ #define FblMemTaskIsActive() (fblMemProgState >= kFblMemProgState_SuspendPending) /** Default source handle */ #define FBL_MEM_SOURCE_HANDLE_DEFAULT 0u #if defined( FBL_MEM_SOURCE_COUNT ) # if (FBL_MEM_SOURCE_COUNT > 1u) # if defined( FBL_MEM_ENABLE_MULTI_SOURCE ) # else /** Multiple input sources */ # define FBL_MEM_ENABLE_MULTI_SOURCE # endif /* FBL_MEM_ENABLE_MULTI_SOURCE */ # endif /* FBL_MEM_SOURCE_COUNT > 1u */ #endif /* FBL_MEM_SOURCE_COUNT */ /* No additional remapping required, simply cast to expected type */ # define FblMemRemapStatus(status) ((FBL_MEM_STATUS_TYPE)(status)) #if defined( FBL_MEM_PROC_SEGMENTATION ) #else /** Set data processing segmentation to default value */ # define FBL_MEM_PROC_SEGMENTATION FBL_MEM_PROC_BUFFER_SIZE #endif /* FBL_MEM_PROC_SEGMENTATION */ #if defined( FBL_MEM_ENABLE_VERIFY_PIPELINED ) /** If the read-verify operation takes a long time and delays the download of a logical block, this define can be * overwritten to shift the delay by read-verify towards the end of the logical block download. The total time for * the logical block download will NOT change, however. The value of this define should be at most the maximum number * of download segments - 1 */ # if defined( FBL_MEM_VERIFY_PIPELINED_JOB_COUNT ) # else /* FBL_MEM_VERIFY_PIPELINED_JOB_COUNT */ # define FBL_MEM_VERIFY_PIPELINED_JOB_COUNT 1u # endif /* FBL_MEM_VERIFY_PIPELINED_JOB_COUNT */ #endif /* FBL_MEM_ENABLE_VERIFY_PIPELINED */ /*-- Compatibility remapping of configuration switches-----------------------*/ #if defined( FBL_ENABLE_GAP_FILL ) # if defined( FBL_MEM_ENABLE_GAP_FILL) || \ defined( FBL_MEM_DISABLE_GAP_FILL ) /* Gap fill handling explicitly defined outside */ # else # define FBL_MEM_ENABLE_GAP_FILL # endif /* FBL_MEM_ENABLE_GAP_FILL */ #endif /* FBL_ENABLE_GAP_FILL */ /*-- Remap configuration switches--------------------------------------------*/ #if ( defined( FBL_MEM_ENABLE_VERIFY_PIPELINED ) && \ defined( FBL_MEM_ENABLE_VERIFY_PIPELINED_ADDRESS_LENGTH ) ) /** On-the-fly verification includes address and length information */ # define FBL_MEM_ENABLE_VERIFY_ADDRESS_LENGTH /** Size of address and length information */ # define FBL_MEM_VERIFY_ADDRESS_LENGTH_SIZE 4u /** Size of address and length information */ # define FBL_MEM_VERIFY_ADDRESS_LENGTH_BUFFER_SIZE (2u * FBL_MEM_VERIFY_ADDRESS_LENGTH_SIZE) #endif /* (FBL_MEM_ENABLE_VERIFY_INPUT && FBL_MEM_ENABLE_VERIFY_INPUT_ADDRESS_LENGTH) || (FBL_MEM_ENABLE_VERIFY_PIPELINED && FBL_MEM_ENABLE_VERIFY_PIPELINED_ADDRESS_LENGTH) */ #if defined( FBL_MEM_ENABLE_VERIFY_PIPELINED ) # if defined( FBL_MEM_ENABLE_VERIFY_ADDRESS_LENGTH ) /** Reserve an additional entry for address information */ # define FBL_MEM_QUEUE_ENTRIES_VERIFY_PIPE_READ (FBL_MEM_VERIFY_PIPELINED_JOB_COUNT + 1u) # else /* FBL_MEM_ENABLE_VERIFY_ADDRESS_LENGTH */ /** Reserve one entry in dedicated queue per job */ # define FBL_MEM_QUEUE_ENTRIES_VERIFY_PIPE_READ (FBL_MEM_VERIFY_PIPELINED_JOB_COUNT) # endif /* FBL_MEM_ENABLE_VERIFY_ADDRESS_LENGTH */ /** Reserve configured number of entries for read, update and finalization jobs */ # define FBL_MEM_QUEUE_ENTRIES_VERIFY_PIPE (FBL_MEM_QUEUE_ENTRIES_VERIFY_PIPE_READ + 2u) #else /* FBL_MEM_ENABLE_VERIFY_PIPELINED */ # define FBL_MEM_QUEUE_ENTRIES_VERIFY_PIPE 0u #endif /* FBL_MEM_ENABLE_VERIFY_PIPELINED */ #if defined( FBL_ENABLE_PIPELINED_PROGRAMMING ) || \ defined( FBL_MEM_ENABLE_VERIFY_PIPELINED ) /** Pipelined operation */ # define FBL_MEM_ENABLE_PIPELINING #endif /* FBL_ENABLE_PIPELINED_PROGRAMMING || FBL_MEM_ENABLE_VERIFY_PIPELINED */ #if defined( FBL_MEM_ENABLE_VERIFY_OUTPUT ) || \ defined( FBL_MEM_ENABLE_GAP_FILL ) # if defined( FBL_MEM_ENABLE_SEGMENT_HANDLING ) || \ defined( FBL_MEM_DISABLE_SEGMENT_HANDLING ) /* Segment handling explicitly defined outside If segments are required by signature/checksum verification on output data but segment handlings is disabled the correct segments have to be handled outside! */ # else /** Segment handling required for signature/checksum verification on output data */ # define FBL_MEM_ENABLE_SEGMENT_HANDLING # endif /* FBL_MEM_ENABLE_SEGMENT_HANDLING */ #endif /* FBL_MEM_ENABLE_VERIFY_OUTPUT || FBL_MEM_ENABLE_GAP_FILL */ #if defined( FBL_MEM_ENABLE_VERIFY_OUTPUT ) || \ defined( FBL_MEM_ENABLE_VERIFY_PIPELINED ) || \ defined( FBL_MEM_ENABLE_SEGMENT_HANDLING ) || \ defined( FBL_ENABLE_PROCESSED_DATA_LENGTH ) || \ defined( FBL_MEM_ENABLE_STREAM_OUTPUT ) || \ defined( FBL_MEM_ENABLE_GAP_FILL ) || \ defined( FBL_MEM_ENABLE_PROGRESS_INFO ) /** Persistent storage of block information */ # define FBL_MEM_ENABLE_GLOBAL_BLOCK_INFO #endif /* FBL_MEM_ENABLE_VERIFY_OUTPUT || FBL_MEM_ENABLE_VERIFY_INPUT || FBL_MEM_ENABLE_VERIFY_PIPELINED || FBL_MEM_ENABLE_SEGMENT_HANDLING || FBL_MEM_ENABLE_PASSTHROUGH || FBL_ENABLE_PROCESSED_DATA_LENGTH || FBL_MEM_ENABLE_STREAM_OUTPUT || FBL_MEM_ENABLE_GAP_FILL || FBL_MEM_ENABLE_PROGRESS_INFO */ /* Allow overwrite of certain data types or defines by using FBL_MEM_VERIFY__OVERWRITE defines / macros */ /*-- On-the-fly verification ------------------------------------------------*/ #if defined( FBL_MEM_VERIFY_OK_OVERWRITE ) #define FBL_MEM_VERIFY_OK (FBL_MEM_VERIFY_OK_OVERWRITE) #else #define FBL_MEM_VERIFY_OK (tFblMemVerifyStatus)(SECM_OK) #endif #if defined( FBL_MEM_VERIFY_STATE_INIT_OVERWRITE ) #define FBL_MEM_VERIFY_STATE_INIT (FBL_MEM_VERIFY_STATE_INIT_OVERWRITE) #else #define FBL_MEM_VERIFY_STATE_INIT kHashInit #endif #if defined( FBL_MEM_VERIFY_STATE_COMPUTE_OVERWRITE ) #define FBL_MEM_VERIFY_STATE_COMPUTE (FBL_MEM_VERIFY_STATE_COMPUTE_OVERWRITE) #else #define FBL_MEM_VERIFY_STATE_COMPUTE kHashCompute #endif #if defined( FBL_MEM_VERIFY_STATE_FINALIZE_OVERWRITE ) #define FBL_MEM_VERIFY_STATE_FINALIZE (FBL_MEM_VERIFY_STATE_FINALIZE_OVERWRITE) #else #define FBL_MEM_VERIFY_STATE_FINALIZE kHashFinalize #endif #if defined( FBL_MEM_VERIFY_STATE_VERIFY_OVERWRITE ) #define FBL_MEM_VERIFY_STATE_VERIFY (FBL_MEM_VERIFY_STATE_VERIFY_OVERWRITE) #else #define FBL_MEM_VERIFY_STATE_VERIFY kSigVerify #endif /*-- Error handling ---------------------------------------------------------*/ /* Helper macros for status definitions */ #define FBL_MEM_STATUS_NAME(name) kFblMemStatus_ ## name /* PRQA S 0342 */ /* MD_MSR_Rule20.10_0342 */ #define FBL_MEM_STATUS_DEFINE(name) FBL_MEM_STATUS_ ## name /* PRQA S 0342 */ /* MD_MSR_Rule20.10_0342 */ #if defined( FBL_MEM_ENABLE_STATUS_OVERWRITE ) /** Overwrite error codes by OEM dependent value */ # define FBL_MEM_STATUS_DEFINITION(name) FBL_MEM_STATUS_NAME(name) = FBL_MEM_STATUS_DEFINE(name) #else /** Use automatically numbered error codes */ # define FBL_MEM_STATUS_DEFINITION(name) FBL_MEM_STATUS_NAME(name) #endif /* FBL_MEM_ENABLE_STATUS_OVERWRITE */ #if defined( FBL_MEM_ENABLE_STATUS_OVERWRITE ) # if defined( FBL_MEM_STATUS_ProgramOverflow ) # else /* Status code not required: remap to default */ # define FBL_MEM_STATUS_ProgramOverflow FBL_MEM_STATUS_Failed # endif # if defined( FBL_MEM_STATUS_VerifyCompute ) # else # error Status overwrite value missing: FBL_MEM_STATUS_VerifyCompute # endif # if defined( FBL_MEM_STATUS_VerifyFinalize ) # else # error Status overwrite value missing: FBL_MEM_STATUS_VerifyFinalize # endif # if defined( FBL_MEM_STATUS_SegmentStartVerifyInit ) # else # if defined( FBL_MEM_STATUS_BlockStartVerifyInit ) /* Compatibility remapping (API < 2.2.0) */ # define FBL_MEM_STATUS_SegmentStartVerifyInit FBL_MEM_STATUS_BlockStartVerifyInit # else # error Status overwrite value missing: FBL_MEM_STATUS_SegmentStartVerifyInit # endif # endif # if defined( FBL_MEM_EXT_STATUS_BlockStartVerifyInit ) /* Compatibility remapping (API < 2.2.0) */ # define FBL_MEM_EXT_STATUS_SegmentStartVerifyInit(status) FBL_MEM_EXT_STATUS_BlockStartVerifyInit(status) # endif # if defined( FBL_MEM_STATUS_BlockEndVerifyFinalize ) # else # error Status overwrite value missing: FBL_MEM_STATUS_BlockEndVerifyFinalize # endif # if defined( FBL_MEM_STATUS_BlockVerifyInputVerify ) # else /* Status code not required: remap to default */ # define FBL_MEM_STATUS_BlockVerifyInputVerify FBL_MEM_STATUS_Failed # endif # if defined( FBL_MEM_STATUS_BlockVerifyPipeVerify ) # else # error Status overwrite value missing: FBL_MEM_STATUS_BlockVerifyPipeVerify # endif # if defined( FBL_MEM_STATUS_BlockVerifyOutputVerify ) # else # error Status overwrite value missing: FBL_MEM_STATUS_BlockVerifyOutputVerify # endif # if defined( FBL_MEM_STATUS_BlockStartParam ) # else # error Status overwrite value missing: FBL_MEM_STATUS_BlockStartParam # endif # if defined( FBL_MEM_STATUS_SegmentStartVerifyCompute ) # else # error Status overwrite value missing: FBL_MEM_STATUS_SegmentStartVerifyCompute # endif # if defined( FBL_MEM_STATUS_DataProc ) # else # error Status overwrite value missing: FBL_MEM_STATUS_DataProc # endif # if defined( FBL_MEM_STATUS_DataProcConsume ) # else # error Status overwrite value missing: FBL_MEM_STATUS_DataProcConsume # endif # if defined( FBL_MEM_STATUS_DataProcDeinit ) # else # error Status overwrite value missing: FBL_MEM_STATUS_DataProcDeinit # endif # if defined( FBL_MEM_STATUS_SegmentStartStreamOutInit ) # else /* Status code not defined: remap to data processing code */ # define FBL_MEM_STATUS_SegmentStartStreamOutInit FBL_MEM_STATUS_SegmentStartDataProcInit # endif # if defined( FBL_MEM_STATUS_StreamOutput ) # else /* Status code not required: remap to default */ # define FBL_MEM_STATUS_StreamOutput FBL_MEM_STATUS_Failed # endif # if defined( FBL_MEM_STATUS_StreamOutputConsume ) # else /* Status code not required: remap to default */ # define FBL_MEM_STATUS_StreamOutputConsume FBL_MEM_STATUS_Failed # endif # if defined( FBL_MEM_STATUS_StreamOutputOverflow ) # else /* Status code not required: remap to default */ # define FBL_MEM_STATUS_StreamOutputOverflow FBL_MEM_STATUS_Failed # endif # if defined( FBL_MEM_STATUS_StreamOutputDeinit ) # else /* Status code not required: remap to default */ # define FBL_MEM_STATUS_StreamOutputDeinit FBL_MEM_STATUS_Failed # endif # if defined( FBL_MEM_STATUS_DriverResumeWrite ) # else /* Status code not required: remap to default */ # define FBL_MEM_STATUS_DriverResumeWrite FBL_MEM_STATUS_Failed # endif # if defined( FBL_MEM_STATUS_DriverRemainder ) # else /* Status code not required: remap to default */ # define FBL_MEM_STATUS_DriverRemainder FBL_MEM_STATUS_Failed # endif # if defined( FBL_MEM_STATUS_BlockEraseSequence ) # else # error Status overwrite value missing: FBL_MEM_STATUS_BlockEraseSequence # endif # if defined( FBL_MEM_STATUS_EraseOutsideFbt ) # else # error Status overwrite value missing: FBL_MEM_STATUS_EraseOutsideFbt # endif # if defined( FBL_MEM_STATUS_EraseDriverNotReady ) # else # error Status overwrite value missing: FBL_MEM_STATUS_EraseDriverNotReady # endif # if defined( __ApplFblMemPreErase ) # if defined( FBL_MEM_STATUS_ErasePreErase ) # else # error Status overwrite value missing: FBL_MEM_STATUS_ErasePreErase # endif # else # if defined( FBL_MEM_STATUS_ErasePreErase ) # else /* Status code not required: remap to default */ # define FBL_MEM_STATUS_ErasePreErase FBL_MEM_STATUS_Failed # endif # endif /* FBL_MEM_ENABLE_ERASE && __ApplFblMemPreErase */ # if defined( __ApplFblMemPostErase ) # if defined( FBL_MEM_STATUS_ErasePostErase ) # else # error Status overwrite value missing: FBL_MEM_STATUS_ErasePostErase # endif # else # if defined( FBL_MEM_STATUS_ErasePostErase ) # else /* Status code not required: remap to default */ # define FBL_MEM_STATUS_ErasePostErase FBL_MEM_STATUS_Failed # endif # endif /* FBL_MEM_ENABLE_ERASE && __ApplFblMemPostErase */ # if defined( __ApplFblMemDriverReady ) # if defined( FBL_MEM_STATUS_EraseDriverNotReady ) # else # error Status overwrite value missing: FBL_MEM_STATUS_EraseDriverNotReady # endif # else # if defined( FBL_MEM_STATUS_EraseDriverNotReady ) # else /* Status code not required: remap to default */ # define FBL_MEM_STATUS_EraseDriverNotReady FBL_MEM_STATUS_Failed # endif # endif /* FBL_MEM_ENABLE_ERASE && __ApplFblMemDriverReady */ # if defined( FBL_MEM_STATUS_SegmentStartSegmentCount ) # else # error Status overwrite value missing: FBL_MEM_STATUS_SegmentStartSegmentCount # endif # if defined( __ApplFblMemPostSegmentEnd ) # if defined( FBL_MEM_STATUS_SegmentEndPost ) # else # error Status overwrite value missing: FBL_MEM_STATUS_SegmentEndPost # endif # else # if defined( FBL_MEM_STATUS_SegmentEndPost ) # else /* Status code not required: remap to default */ # define FBL_MEM_STATUS_SegmentEndPost FBL_MEM_STATUS_Failed # endif # endif /* __ApplFblMemPostSegmentEnd */ # if defined( __ApplFblMemDriverReady ) # if defined( FBL_MEM_STATUS_ProgramDriverNotReady ) # else # error Status overwrite value missing: FBL_MEM_STATUS_ProgramDriverNotReady # endif # else # if defined( FBL_MEM_STATUS_ProgramDriverNotReady ) # else /* Status code not required: remap to default */ # define FBL_MEM_STATUS_ProgramDriverNotReady FBL_MEM_STATUS_Failed # endif # endif /* __ApplFblMemDriverReady */ # if defined( __ApplFblMemPreWrite ) # if defined( FBL_MEM_STATUS_ProgramPreWrite ) # else # error Status overwrite value missing: FBL_MEM_STATUS_ProgramPreWrite # endif # else # if defined( FBL_MEM_STATUS_ProgramPreWrite ) # else /* Status code not required: remap to default */ # define FBL_MEM_STATUS_ProgramPreWrite FBL_MEM_STATUS_Failed # endif # endif /* __ApplFblMemPreWrite */ # if defined( __ApplFblMemPostWrite ) # if defined( FBL_MEM_STATUS_ProgramPostWrite ) # else # error Status overwrite value missing: FBL_MEM_STATUS_ProgramPostWrite # endif # else # if defined( FBL_MEM_STATUS_ProgramPostWrite ) # else /* Status code not required: remap to default */ # define FBL_MEM_STATUS_ProgramPostWrite FBL_MEM_STATUS_Failed # endif # endif /* __ApplFblMemPostWrite */ #endif /* FBL_MEM_ENABLE_STATUS_OVERWRITE || FBL_MEM_ENABLE_STATUS_REMAPPING */ /* Options for extended verification API */ #define FBL_MEM_VERIFY_INPUT_OPT 0u #define FBL_MEM_VERIFY_PROC_OPT 1u #define FBL_MEM_VERIFY_PIPE_OPT 2u #define FBL_MEM_VERIFY_OUTPUT_OPT 3u #define FBL_MEM_CHK_OPTION(a, b) (( a & (1u << b) ) != 0u) #define FBL_MEM_OPT_INPUT_MASK (1u << FBL_MEM_VERIFY_INPUT_OPT) #define FBL_MEM_OPT_PROC_MASK (1u << FBL_MEM_VERIFY_PROC_OPT) #define FBL_MEM_OPT_Pipe_MASK (1u << FBL_MEM_VERIFY_PIPE_OPT) #define FBL_MEM_OPT_OUTPUT_MASK (1u << FBL_MEM_VERIFY_OUTPUT_OPT) /*********************************************************************************************************************** * TYPEDEFS **********************************************************************************************************************/ /*-- On-the-fly verification ------------------------------------------------*/ #if defined( FBL_MEM_VERIFY_STATUS_TYPE_OVERWRITE ) typedef FBL_MEM_VERIFY_STATUS_TYPE_OVERWRITE tFblMemVerifyStatus; #else typedef SecM_StatusType tFblMemVerifyStatus; #endif /* FBL_MEM_VERIFY_STATUS_TYPE_OVERWRITE */ #if defined( FBL_MEM_VERIFY_PARAM_TYPE_INPUT_OVERWRITE ) typedef FBL_MEM_VERIFY_PARAM_TYPE_INPUT_OVERWRITE tFblMemVerifyParamInput; #else typedef SecM_SignatureParamType tFblMemVerifyParamInput; #endif /* FBL_MEM_VERIFY_PARAM_TYPE_INPUT_OVERWRITE */ #if defined( FBL_MEM_VERIFY_PARAM_TYPE_OUTPUT_OVERWRITE ) typedef FBL_MEM_VERIFY_PARAM_TYPE_OUTPUT_OVERWRITE tFblMemVerifyParamOutput; #else typedef SecM_VerifyParamType tFblMemVerifyParamOutput; #endif /* FBL_MEM_VERIFY_PARAM_TYPE_OUTPUT_OVERWRITE */ #if defined( FBL_MEM_VERIFY_LENGTH_TYPE_OVERWRITE ) typedef FBL_MEM_VERIFY_LENGTH_TYPE_OVERWRITE tFblMemVerifyLength; #else typedef SecM_LengthType tFblMemVerifyLength; #endif /* FBL_MEM_VERIFY_LENGTH_TYPE_OVERWRITE */ #if defined( FBL_MEM_VERIFY_SIZE_TYPE_OVERWRITE ) typedef FBL_MEM_VERIFY_SIZE_TYPE_OVERWRITE tFblMemVerifySize; #else typedef SecM_SizeType tFblMemVerifySize; #endif /* FBL_MEM_VERIFY_SIZE_TYPE_OVERWRITE */ #if defined( FBL_MEM_VERIFY_ADDRESS_TYPE_OVERWRITE ) typedef FBL_MEM_VERIFY_ADDRESS_TYPE_OVERWRITE tFblMemVerifyAddr; #else typedef SecM_AddrType tFblMemVerifyAddr; #endif /* FBL_MEM_VERIFY_ADDRESS_TYPE_OVERWRITE */ #if defined( FBL_MEM_VERIFY_DATA_PTR_TYPE_OVERWRITE ) typedef FBL_MEM_VERIFY_DATA_PTR_TYPE_OVERWRITE tFblMemVerifyDataPtr; #else typedef V_MEMRAM1 vuint8 V_MEMRAM2 V_MEMRAM3 * tFblMemVerifyDataPtr; #endif /* FBL_MEM_VERIFY_DATA_PTR_TYPE_OVERWRITE */ #if defined( FBL_MEM_VERIFY_WD_FCT_TYPE_OVERWRITE ) typedef FBL_MEM_VERIFY_WD_FCT_TYPE_OVERWRITE tFblMemVerifyWdFct; #else typedef FL_WDTriggerFctType tFblMemVerifyWdFct; #endif /* FBL_MEM_VERIFY_WD_FCT_TYPE_OVERWRITE */ #if defined( FBL_MEM_VERIFY_READ_FCT_TYPE_OVERWRITE ) typedef FBL_MEM_VERIFY_READ_FCT_TYPE_OVERWRITE tFblMemVerifyReadFct; #else typedef FL_ReadMemoryFctType tFblMemVerifyReadFct; #endif /* FBL_MEM_VERIFY_READ_FCT_TYPE_OVERWRITE */ #if defined( FBL_MEM_VERIFY_FCT_INPUT_TYPE_OVERWRITE ) typedef FBL_MEM_VERIFY_FCT_INPUT_TYPE_OVERWRITE(tFblMemVerifyFctInput); #else typedef FBL_CALL_TYPE tFblMemVerifyStatus (*tFblMemVerifyFctInput) (V_MEMRAM1 tFblMemVerifyParamInput V_MEMRAM2 V_MEMRAM3 *fp); #endif /* FBL_MEM_VERIFY_FCT_INPUT_TYPE_OVERWRITE */ #if defined( FBL_MEM_VERIFY_FCT_OUTPUT_TYPE_OVERWRITE ) typedef FBL_MEM_VERIFY_FCT_OUTPUT_TYPE_OVERWRITE(tFblMemVerifyFctOutput); #else typedef FBL_CALL_TYPE tFblMemVerifyStatus (*tFblMemVerifyFctOutput) (V_MEMRAM1 tFblMemVerifyParamOutput V_MEMRAM2 V_MEMRAM3 *fp); #endif /* FBL_MEM_VERIFY_FCT_OUTPUT_TYPE_OVERWRITE */ #if defined( FBL_MEM_SEGMENT_LIST_TYPE_OVERWRITE ) typedef FBL_MEM_SEGMENT_LIST_TYPE_OVERWRITE tFblMemSegmentList; #else typedef FL_SegmentListType tFblMemSegmentList; #endif /* FBL_MEM_SEGMENT_LIST_TYPE_OVERWRITE */ #if defined( FBL_MEM_SEGMENT_LIST_ENTRY_TYPE_OVERWRITE ) typedef FBL_MEM_SEGMENT_LIST_ENTRY_TYPE_OVERWRITE tFblMemSegmentListEntry; #else typedef FL_SegmentInfoType tFblMemSegmentListEntry; #endif /* FBL_MEM_SEGMENT_LIST_ENTRY_TYPE_OVERWRITE */ /* Options type for extended verification API */ typedef vuint8 tFblMemVerifyOption; /** Error codes reported by FblMem routines */ typedef enum { /* Define status codes: kFblMemStatus_ */ /* Default */ FBL_MEM_STATUS_DEFINITION(Ok) /* 0x00 */ ,FBL_MEM_STATUS_DEFINITION(Failed) /* 0x01 */ /* BlockErase indication */ ,FBL_MEM_STATUS_DEFINITION(BlockEraseSequence) /* 0x02 */ /* BlockStart indication */ ,FBL_MEM_STATUS_DEFINITION(BlockStartSequence) /* 0x03 */ ,FBL_MEM_STATUS_DEFINITION(BlockStartParam) /* 0x04 */ /* BlockEnd indication */ ,FBL_MEM_STATUS_DEFINITION(BlockEndSequence) /* 0x05 */ ,FBL_MEM_STATUS_DEFINITION(BlockEndVerifyFinalize) /* 0x06 */ /* BlockVerify */ ,FBL_MEM_STATUS_DEFINITION(BlockVerifySequence) /* 0x07 */ ,FBL_MEM_STATUS_DEFINITION(BlockVerifyInputVerify) /* 0x08 */ ,FBL_MEM_STATUS_DEFINITION(BlockVerifyProcessedVerify) /* 0x09 */ ,FBL_MEM_STATUS_DEFINITION(BlockVerifyPipeVerify) /* 0x0A */ ,FBL_MEM_STATUS_DEFINITION(BlockVerifyOutputVerify) /* 0x0B */ /* SegmentStart indication */ ,FBL_MEM_STATUS_DEFINITION(SegmentStartSequence) /* 0x0C */ ,FBL_MEM_STATUS_DEFINITION(SegmentStartDataProcInit) /* 0x0D */ ,FBL_MEM_STATUS_DEFINITION(SegmentStartStreamOutInit) /* 0x0E */ ,FBL_MEM_STATUS_DEFINITION(SegmentStartVerifyInit) /* 0x0F */ ,FBL_MEM_STATUS_DEFINITION(SegmentStartVerifyCompute) /* 0x10 */ ,FBL_MEM_STATUS_DEFINITION(SegmentStartSegmentCount) /* 0x11 */ /* SegmentEnd indication */ ,FBL_MEM_STATUS_DEFINITION(SegmentEndSequence) /* 0x12 */ ,FBL_MEM_STATUS_DEFINITION(SegmentEndInsufficientData) /* 0x13 */ ,FBL_MEM_STATUS_DEFINITION(SegmentEndPost) /* 0x14 */ /* Data indication */ ,FBL_MEM_STATUS_DEFINITION(DataIndSequence) /* 0x15 */ ,FBL_MEM_STATUS_DEFINITION(DataIndParam) /* 0x16 */ ,FBL_MEM_STATUS_DEFINITION(DataIndOverflow) /* 0x17 */ /* Data processing */ ,FBL_MEM_STATUS_DEFINITION(DataProc) /* 0x18 */ ,FBL_MEM_STATUS_DEFINITION(DataProcConsume) /* 0x19 */ ,FBL_MEM_STATUS_DEFINITION(DataProcDeinit) /* 0x1A */ /* Stream output */ ,FBL_MEM_STATUS_DEFINITION(StreamOutput) /* 0x1B */ ,FBL_MEM_STATUS_DEFINITION(StreamOutputConsume) /* 0x1C */ ,FBL_MEM_STATUS_DEFINITION(StreamOutputOverflow) /* 0x1D */ ,FBL_MEM_STATUS_DEFINITION(StreamOutputDeinit) /* 0x1E */ /* Memory driver */ ,FBL_MEM_STATUS_DEFINITION(DriverResumeWrite) /* 0x1F */ ,FBL_MEM_STATUS_DEFINITION(DriverWrite) /* 0x20 */ ,FBL_MEM_STATUS_DEFINITION(DriverErase) /* 0x21 */ ,FBL_MEM_STATUS_DEFINITION(DriverRemainder) /* 0x22 */ ,FBL_MEM_STATUS_DEFINITION(DriverSuspendWrite) /* 0x23 */ /* Programming operation */ ,FBL_MEM_STATUS_DEFINITION(ProgramOverflow) /* 0x24 */ ,FBL_MEM_STATUS_DEFINITION(ProgramOutsideFbt) /* 0x25 */ ,FBL_MEM_STATUS_DEFINITION(ProgramUnalignedAddress) /* 0x26 */ ,FBL_MEM_STATUS_DEFINITION(ProgramDriverNotReady) /* 0x27 */ ,FBL_MEM_STATUS_DEFINITION(ProgramPreWrite) /* 0x28 */ ,FBL_MEM_STATUS_DEFINITION(ProgramPostWrite) /* 0x29 */ /* Erase operation */ ,FBL_MEM_STATUS_DEFINITION(EraseOutsideFbt) /* 0x2A */ ,FBL_MEM_STATUS_DEFINITION(EraseDriverNotReady) /* 0x2B */ ,FBL_MEM_STATUS_DEFINITION(ErasePreErase) /* 0x2C */ ,FBL_MEM_STATUS_DEFINITION(ErasePostErase) /* 0x2D */ /* On-the-fly verification */ ,FBL_MEM_STATUS_DEFINITION(VerifyCompute) /* 0x2E */ ,FBL_MEM_STATUS_DEFINITION(VerifyFinalize) /* 0x2F */ /* Pass-through */ ,FBL_MEM_STATUS_DEFINITION(PassThroughLocal) /* 0x30 */ ,FBL_MEM_STATUS_DEFINITION(PassThroughRemote) /* 0x31 */ #if defined( FBL_MEM_STATUS_ConditionCheck0 ) ,FBL_MEM_STATUS_DEFINITION(ConditionCheck0) /* 0x32 */ #endif /* FBL_MEM_STATUS_ConditionCheck0 */ #if defined( FBL_MEM_STATUS_ConditionCheck1 ) ,FBL_MEM_STATUS_DEFINITION(ConditionCheck1) /* 0x33 */ #endif /* FBL_MEM_STATUS_ConditionCheck1 */ #if defined( FBL_MEM_STATUS_ConditionCheck2 ) ,FBL_MEM_STATUS_DEFINITION(ConditionCheck2) /* 0x34 */ #endif /* FBL_MEM_STATUS_ConditionCheck2 */ #if defined( FBL_MEM_STATUS_ConditionCheck3 ) ,FBL_MEM_STATUS_DEFINITION(ConditionCheck3) /* 0x35 */ #endif /* FBL_MEM_STATUS_ConditionCheck3 */ #if defined( FBL_MEM_STATUS_ConditionCheck4 ) ,FBL_MEM_STATUS_DEFINITION(ConditionCheck4) /* 0x36 */ #endif /* FBL_MEM_STATUS_ConditionCheck4 */ #if defined( FBL_MEM_STATUS_ConditionCheck5 ) ,FBL_MEM_STATUS_DEFINITION(ConditionCheck5) /* 0x37 */ #endif /* FBL_MEM_STATUS_ConditionCheck5 */ #if defined( FBL_MEM_STATUS_ConditionCheck6 ) ,FBL_MEM_STATUS_DEFINITION(ConditionCheck6) /* 0x38 */ #endif /* FBL_MEM_STATUS_ConditionCheck6 */ #if defined( FBL_MEM_STATUS_ConditionCheck7 ) ,FBL_MEM_STATUS_DEFINITION(ConditionCheck7) /* 0x39 */ #endif /* FBL_MEM_STATUS_ConditionCheck7 */ #if defined( FBL_MEM_STATUS_ConditionCheck8 ) ,FBL_MEM_STATUS_DEFINITION(ConditionCheck8) /* 0x3A */ #endif /* FBL_MEM_STATUS_ConditionCheck8 */ #if defined( FBL_MEM_STATUS_ConditionCheck9 ) ,FBL_MEM_STATUS_DEFINITION(ConditionCheck9) /* 0x3B */ #endif /* FBL_MEM_STATUS_ConditionCheck9 */ } tFblMemStatus; /** Memory type */ typedef enum { kFblMemType_RAM = 0u, /* Volatile memory */ kFblMemType_ROM /* Non-volatile memory */ } tFblMemType; /** State of programming operation */ typedef enum { kFblMemProgState_Idle = 0u, kFblMemProgState_Error, kFblMemProgState_Suspended, kFblMemProgState_SuspendPending, kFblMemProgState_Checkpoint, kFblMemProgState_Pending } tFblMemProgState; /** Pointer type to byte data in RAM */ typedef V_MEMRAM1 vuint8 V_MEMRAM2 V_MEMRAM3 * tFblMemRamData; /** Pointer type to constant byte data in RAM */ typedef const V_MEMRAM1 vuint8 V_MEMRAM2 V_MEMRAM3 * tFblMemConstRamData; /** Data format identifier */ typedef vuint8 tFblMemDfi; /** Input verification routine */ typedef struct { tFblMemVerifyFctInput function; V_MEMRAM1 tFblMemVerifyParamInput V_MEMRAM2 V_MEMRAM3 * param; } tFblMemVerifyRoutineInput; /** Output verification routine */ typedef struct { tFblMemVerifyFctOutput function; V_MEMRAM1 tFblMemVerifyParamOutput V_MEMRAM2 V_MEMRAM3 * param; } tFblMemVerifyRoutineOutput; /** Information passed in block erase / start indication */ typedef struct { tFblAddress targetAddress; /**< Target address (erase operation) */ tFblLength targetLength; /**< Target length (erase operation) */ /* Used for signature verification */ tFblAddress logicalAddress; /**< Logical address (verification operation) */ tFblLength logicalLength; /**< Logical length (verification operation) */ tFblMemVerifyRoutineInput verifyRoutineInput; /**< On-the-fly verification on input data */ tFblMemVerifyRoutineInput verifyRoutineProcessed; /**< On-the-fly verification on processed data */ tFblMemVerifyRoutineInput verifyRoutinePipe; /**< Pipelined verification on output data */ tFblMemVerifyRoutineOutput verifyRoutineOutput; /**< Verification on output data */ tFblMemVerifyReadFct readFct; /**< Memory read function, used by pipelined and output verification */ V_MEMRAM1 tFblMemSegmentList V_MEMRAM2 V_MEMRAM3 * segmentList; /**< List of programmed segments, used by output verification */ vuint32 maxSegments; /**< Maximum number of entries in segment list */ } tFblMemBlockInfo; /** Verification data */ typedef struct { tFblMemRamData data; /**< Pointer to verification data (signature/checksum) */ tFblLength length; /**< Length of verification data */ } tFblMemVerifyData; /** Information passed in block verify */ typedef struct { tFblMemVerifyData verifyDataInput; /**< On-the-fly verification on input data */ tFblMemVerifyData verifyDataProcessed; /**< On-the-fly verification on processed data */ tFblMemVerifyData verifyDataPipe; /**< Pipelined verification on output data */ tFblMemVerifyData verifyDataOutput; /**< Verification on output data */ } tFblMemBlockVerifyData; /** Information passed in segment start indication */ typedef struct { tFblAddress targetAddress; /* Target address (program operation) */ tFblLength targetLength; /* Target length (program operation) */ /* Used for signature verification */ tFblAddress logicalAddress; /* Logical address (verification operation) */ tFblLength logicalLength; /* Logical length (verification operation) */ /* Handling info */ tFblMemType type; /* Type (RAM / ROM) */ tFblMemDfi dataFormat; /* Data format identifier (data processing) */ } tFblMemSegmentInfo; /** Return type for watchdog trigger */ #if defined( FBL_MEM_TRIGGER_STATUS_OVERWRITE ) typedef FBL_MEM_TRIGGER_STATUS_OVERWRITE tFblMemTriggerStatus; #else typedef vuint8 tFblMemTriggerStatus; #endif /** Input source handle */ typedef vuintx tFblMemInputSource; #if defined( FBL_MEM_ENABLE_PROGRESS_INFO ) /** Operation types reported in progress information */ typedef enum { kFblMemProgressType_Erase, /**< Erase operation */ kFblMemProgressType_Program, /**< Programming operation (may include gap fill) */ kFblMemProgressType_GapFill, /**< Concluding gap fill operation */ kFblMemProgressType_Verify, /**< Verification operation */ kFblMemProgressType_Undefined /**< Undefined, used internally */ } tFblMemProgressType; /** Progress information */ typedef struct { tFblMemProgressType type; /**< Operation type */ tFblAddress logicalAddress; /**< Logical block address */ vuint32 segmentCount; /**< Segment count Typically zero for erase and verification, segment index for programming and index of last segment incremented by one for concluding gap fill */ vuint8 totalProgress; /**< Total operation progress (current block) */ vuint8 partialProgress; /**< Partial operation progress */ } tFblMemProgressInfo; #endif /* FBL_MEM_ENABLE_PROGRESS_INFO */ #if defined( FBL_MEM_ENABLE_STREAM_OUTPUT ) typedef struct { tFblAddress baseAddress; /**< Address of base memory region allowed to be modified */ tFblLength baseLength; /**< Length of base memory region allowed to be modified */ tFblAddress address; /**< Current programming address (based on previously produced length) */ tFblLength length; /**< Current programming remainder (based on previously produced length) */ tFblMemConstRamData inputData; /**< Pointer to input data buffer */ tFblMemRamData outputData; /**< Pointer to output data buffer (not used for stream output) */ void (* watchdog)(void); /**< Watchdog trigger function */ tFblLength inputLength; /**< Length of input data */ tFblLength outputSize; /**< Size of output data buffer (not used for stream output) */ tFblLength consumedLength; /**< Number of consumed input data bytes */ tFblLength producedLength; /**< Number of produced output data bytes (stream output: directly programmed to memory) */ vuint8 mode; /**< Applied data processing mode*/ } tFblMemStreamProcessing; #endif /* FBL_MEM_ENABLE_STREAM_OUTPUT */ /*-- Resumable programming --------------------------------------------------*/ #define FBLLIB_MEM_START_SEC_CODE #include "MemMap.h" /* PRQA S 5087 */ /* MD_MSR_MemMap */ /*********************************************************************************************************************** * FUNCTION PROTOTYPES **********************************************************************************************************************/ #if defined( __cplusplus ) extern "C" { #endif tFblMemRamData FblMemInitPowerOn( void ); tFblMemRamData FblMemInitPowerOnExt( tFblLength preambleLen, tFblMemInputSource sourceHandle ); tFblMemRamData FblMemInit( void ); void FblMemDeinit( void ); tFblMemRamData FblMemGetActiveBuffer( void ); tFblMemStatus FblMemBlockEraseIndication( const V_MEMRAM1 tFblMemBlockInfo V_MEMRAM2 V_MEMRAM3 * block ); tFblMemStatus FblMemBlockStartIndication( V_MEMRAM1 tFblMemBlockInfo V_MEMRAM2 V_MEMRAM3 * block ); tFblMemStatus FblMemBlockEndIndication( void ); tFblMemStatus FblMemBlockVerify( const V_MEMRAM1 tFblMemBlockVerifyData V_MEMRAM2 V_MEMRAM3 * verifyData, V_MEMRAM1 tFblMemVerifyStatus V_MEMRAM2 V_MEMRAM3 * verifyResult ); tFblMemStatus FblMemBlockVerifyExtended( const V_MEMRAM1 tFblMemBlockVerifyData V_MEMRAM2 V_MEMRAM3 * verifyData, V_MEMRAM1 tFblMemVerifyStatus V_MEMRAM2 V_MEMRAM3 * verifyResult, const tFblMemVerifyOption option ); tFblMemStatus FblMemSegmentStartIndication( const V_MEMRAM1 tFblMemSegmentInfo V_MEMRAM2 V_MEMRAM3 * segment ); tFblMemStatus FblMemSegmentEndIndication( V_MEMRAM1 tFblLength V_MEMRAM2 V_MEMRAM3 * writeLength ); tFblMemStatus FblMemDataIndication( tFblMemConstRamData buffer, tFblLength offset, tFblLength length ); void FblMemTask( void ); void FblMemFlushInputData( void ); /* Low level memory operations */ tFblMemStatus FblMemEraseRegion( tFblAddress eraseAddress, tFblLength eraseLength ); tFblMemStatus FblMemProgramBuffer( tFblAddress programAddress,V_MEMRAM1 tFblLength V_MEMRAM2 V_MEMRAM3 * programLength, tFblMemRamData programData ); /* Helper functions */ void FblMemSetInteger( vuintx count, vuint32 input, tFblMemRamData buffer ); vuint32 FblMemGetInteger( vuintx count, tFblMemConstRamData buffer ); #if defined( FBL_MEM_ENABLE_MULTI_SOURCE ) void FblMemLockInputSource( tFblMemInputSource sourceHandle ); #endif #define FBLLIB_MEM_STOP_SEC_CODE #include "MemMap.h" /* PRQA S 5087 */ /* MD_MSR_MemMap */ #define FBLLIB_MEM_RAMCODE_START_SEC_CODE_EXPORT #include "MemMap.h" /* PRQA S 5087 */ /* MD_MSR_MemMap */ void FblMemResumeIndication( void ); #if defined( FBL_MEM_ENABLE_PIPELINING ) void FblMemRxNotification( void ); #endif /* FBL_MEM_ENABLE_PIPELINING */ #define FBLLIB_MEM_RAMCODE_STOP_SEC_CODE_EXPORT #include "MemMap.h" /* PRQA S 5087 */ /* MD_MSR_MemMap */ #if defined( __cplusplus ) } /* extern "C" */ #endif /*********************************************************************************************************************** * GLOBAL DATA **********************************************************************************************************************/ #define FBLLIB_MEM_START_SEC_VAR_EXPORT #include "MemMap.h" /* PRQA S 5087 */ /* MD_MSR_MemMap */ V_MEMRAM0 extern V_MEMRAM1 tFblMemProgState V_MEMRAM2 fblMemProgState; #define FBLLIB_MEM_STOP_SEC_VAR_EXPORT #include "MemMap.h" /* PRQA S 5087 */ /* MD_MSR_MemMap */ /*********************************************************************************************************************** * CONFIGURATION CHECKS **********************************************************************************************************************/ /* Plausibility checks of configuration settings *****************************/ /*-- Integration time -------------------------------------------------------*/ /*-- Compatibility remapping of configuration switches-----------------------*/ /*-- Compile time -----------------------------------------------------------*/ #if defined( FBL_ENABLE_PIPELINED_PROGRAMMING ) || \ defined( FBL_ENABLE_ADAPTIVE_DATA_TRANSFER_RCRRP ) # if defined( FBL_MEM_WRITE_SEGMENTATION ) # else # error Write segmentation not defined # endif # if defined( FBL_ENABLE_UNALIGNED_DATA_TRANSFER ) # else # if ( (FBL_MEM_WRITE_SEGMENTATION & (FBL_MAX_SEGMENT_SIZE - 1u)) != 0u ) # error Write segmentation has to be multiple of segment size # endif # endif /* FBL_ENABLE_UNALIGNED_DATA_TRANSFER */ #endif /* FBL_ENABLE_PIPELINED_PROGRAMMING || FBL_ENABLE_ADAPTIVE_DATA_TRANSFER_RCRRP */ # if defined( FBL_ENABLE_PIPELINED_PROGRAMMING ) # if defined( FBL_MEM_PIPE_PROG_BUFFER_COUNT ) # if ( FBL_MEM_PIPE_PROG_BUFFER_COUNT < 2 ) # error Number of pipelined programming buffers has to be at least two # endif # endif /* FBL_MEM_PIPE_PROG_BUFFER_COUNT */ # endif /* FBL_ENABLE_PIPELINED_PROGRAMMING */ #if defined( FBL_ENABLE_DATA_PROCESSING ) # if defined( FBL_MEM_PROC_BUFFER_SIZE ) # else # error Data processing buffer size not defined # endif # if ( FBL_MEM_PROC_SEGMENTATION > 0xFFFFu ) # error Data processing segmentation exceeds interface constraints # endif # if ( FBL_MEM_PROC_SEGMENTATION > FBL_MEM_PROC_BUFFER_SIZE ) # error Data processing segmentation exceeds buffer size # endif # if ( FBL_MEM_PROC_SEGMENTATION == FBL_MEM_PROC_BUFFER_SIZE ) # else # endif #endif /* FBL_ENABLE_DATA_PROCESSING */ #if defined( FBL_MEM_BUFFER_SIZE ) #else # error Input buffer size not defined #endif /* FBL_MEM_BUFFER_SIZE */ #if defined( FBL_MEM_DEFAULT_PREAMBLE_LENGTH ) #else # error Default preamble length not defined #endif /* FBL_MEM_DEFAULT_PREAMBLE_LENGTH */ #if defined( FBL_MEM_MAX_PREAMBLE_LENGTH ) #else # error Maximum preamble length not defined #endif /* FBL_MEM_MAX_PREAMBLE_LENGTH */ #if defined( FBL_MEM_WD_TRIGGER_DEFAULT ) #else # error Default watchdog trigger return code not defined #endif /* FBL_MEM_WD_TRIGGER_DEFAULT */ #if defined( FBL_MEM_ENABLE_STATUS_OVERWRITE ) # if defined( FBL_MEM_STATUS_Ok ) && \ defined( FBL_MEM_STATUS_Failed ) # else # error Status overwrite or remapping enabled, but actual values missing # endif #endif /* FBL_MEM_ENABLE_STATUS_OVERWRITE || FBL_MEM_ENABLE_STATUS_REMAPPING */ #if defined( FBL_MEM_STATUS_Ok ) || \ defined( FBL_MEM_STATUS_Failed ) # if defined( FBL_MEM_ENABLE_STATUS_OVERWRITE ) # else # error Status values defined, but neither status overwrite nor remapping enabled # endif #endif /* FBL_MEM_STATUS_Ok || FBL_MEM_STATUS_Failed */ #if defined( FBL_MEM_ENABLE_EXT_STATUS ) # if defined( FBL_MEM_EXT_STATUS_Ok ) && \ defined( FBL_MEM_EXT_STATUS_Failed ) # else # error Extended status enabled, but actual macros missing # endif #endif /* FBL_MEM_ENABLE_EXT_STATUS */ #if defined( FBL_MEM_EXT_STATUS_Ok ) || \ defined( FBL_MEM_EXT_STATUS_Failed ) # if defined( FBL_MEM_ENABLE_EXT_STATUS ) # else # error Extended status macros defined, but feature not enabled # endif #endif /* FBL_MEM_EXT_STATUS_Ok || FBL_MEM_EXT_STATUS_Failed */ #if defined( FBL_MEM_ENABLE_STREAM_OUTPUT ) # if defined( __ApplFblMemIsStreamOutputRequired ) # else # error Stream output enabled, but data format check not specified # endif #endif /* FBL_MEM_ENABLE_STREAM_OUTPUT */ #if defined( FBL_MEM_ENABLE_PROGRESS_INFO ) # if defined( FBL_ENABLE_PROCESSED_DATA_LENGTH) # error Combination of progress information with processed data length not supported # endif /* FBL_ENABLE_PROCESSED_DATA_LENGTH */ # if defined( __ApplFblMemReportProgress ) # else # error Progress information enabled, but report callout not specified # endif /* __ApplFblMemReportProgress */ #endif /* FBL_MEM_ENABLE_PROGRESS_INFO */ #endif /* FBL_MEM_H */ /*********************************************************************************************************************** * END OF FILE: FBL_MEM.H **********************************************************************************************************************/