jidhin.angadithazha
/
FLEX-FORD-OBC-BM
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
FLEX-FORD-OBC-BM/Source/bsw/Fbl/fbl_mem.h

1152 lines
54 KiB
C
Raw Permalink Normal View History

Flex OBC Initial Package creation
2026-03-19 11:49:16 +01:00
/***********************************************************************************************************************
* 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_<type>_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_<name> */
/* 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
**********************************************************************************************************************/