AUTOSAR Classic Memory Services

Die Memory Services verwalten nicht-flüchtige Datenblöcke (NvM), abstrahieren Flash- und EEPROM-Technologien (MemIf, Fee, Ea) und gewährleisten Datenkonsistenz und Datensicherheit über ECU-Abschaltzyklen hinweg.

Topic map

Detail view

Select an entry in the outline.

No element data available for this release

BndM

BndM_Init function

Initializes or reinitializes this module.

void BndM_Init(const BndM_ConfigType* ConfigPtr);

BndM_JobEndNotification function

This callback function is called when a FLS job has been finished with positive result.

void BndM_JobEndNotification(void);

BndM_JobErrorNotification function

This callback function is called when a FLS job has been canceled or finished with negative result.

void BndM_JobErrorNotification(void);

BndM_MainFunction function

Schedule function for the background processing.

void BndM_MainFunction(void);

BndM_WriteCancel function

Cancels the writing

void BndM_WriteCancel(void);

BndM_BlockIdType type

Unique identification of an bulk nv block. The BndM_BlockId is assigned by the BndM.

BndM_Block{BlockId.Shortname}Type type

The elements of this structure data type is the C-structured representation of the configured ImplementationDataPrototype.

BndM_ConfigType type

This type of the external data structure shall contain the post build initialization data for the BndM.

BndM_ResultType type

Result of the asynchronous job finish notifications

Ea

Ea_Cancel function

Cancels the ongoing asynchronous operation.

void Ea_Cancel (void);

Ea_EraseImmediateBlock function

Erases the block Block Number.

Std_ReturnType Ea_EraseImmediateBlock (uint16 BlockNumber);

Ea_GetJobResult function

Service to return the Job Result.

MemIf_JobResultType Ea_GetJobResult (void);

Ea_GetStatus function

Service to return the Status.

MemIf_StatusType Ea_GetStatus (void);

Ea_GetVersionInfo function

Service to get the version information of this module.

void Ea_GetVersionInfo (Std_VersionInfoType* VersionInfoPtr);

Ea_Init function

Initializes the EEPROM abstraction module.

void Ea_Init (const Ea_ConfigType* ConfigPtr);

Ea_InvalidateBlock function

Invalidates the block Block Number.

Std_ReturnType Ea_InvalidateBlock (uint16 BlockNumber);

Ea_JobEndNotification function

Service to report to this module the successful end of an asynchronous operation.

void Ea_JobEndNotification (void);

Ea_JobErrorNotification function

Service to report to this module the failure of an asynchronous operation.

void Ea_JobErrorNotification (void);

Ea_MainFunction function

Service to handle the requested jobs and the internal management operations.

void Ea_MainFunction (void);

Ea_Read function

Reads Length bytes of block Blocknumber at offset Block Offset into the buffer Data Buffer Ptr.

Std_ReturnType Ea_Read (uint16 BlockNumber, uint16 BlockOffset, uint8* DataBufferPtr, uint16 Length);

Ea_SetMode function

Function to switch the mode of the underlying EEPROM Driver

void Ea_SetMode (MemIf_ModeType Mode);

Ea_Write function

Writes the contents of the Data Buffer Ptr to the block Block Number.

Std_ReturnType Ea_Write (uint16 BlockNumber, const uint8* DataBufferPtr);

NvM_JobEndNotification function

Function to be used by the underlying memory abstraction to signal end of job without error.

void NvM_JobEndNotification (void);

NvM_JobErrorNotification function

Function to be used by the underlying memory abstraction to signal end of job with error.

void NvM_JobErrorNotification (void);

Ea_ConfigType type

Configuration data structure of the Ea module.

Eep

Eep_Cancel function

Cancels a running job.

void Eep_Cancel(void);

Eep_Compare function

Compares a data block in EEPROM with an EEPROM block in the memory.

Std_ReturnType Eep_Compare(Eep_AddressType EepromAddress, const uint8* DataBufferPtr, Eep_LengthType Length);

Eep_Erase function

Service for erasing EEPROM sections.

Std_ReturnType Eep_Erase(Eep_AddressType EepromAddress, Eep_LengthType Length);

Eep_GetJobResult function

This service returns the result of the last job.

MemIf_JobResultType Eep_GetJobResult(void);

Eep_GetStatus function

Returns the EEPROM status.

MemIf_StatusType Eep_GetStatus(void);

Eep_GetVersionInfo function

Service to get the version information of this module.

void Eep_GetVersionInfo(Std_VersionInfoType* versioninfo);

Eep_Init function

Service for EEPROM initialization.

void Eep_Init(const Eep_ConfigType* ConfigPtr);

Eep_JobEndNotification function

This callback function provided by the module user is called when a job has been completed with a positive result.

void Eep_JobEndNotification(void);

Eep_JobErrorNotification function

This callback function provided by the module user is called when a job has been canceled or finished with negative result.

void Eep_JobErrorNotification(void);

Eep_MainFunction function

Service to perform the processing of the EEPROM jobs (read/write/erase/compare) .

void Eep_MainFunction(void);

Eep_Read function

Reads from EEPROM.

Std_ReturnType Eep_Read(Eep_AddressType EepromAddress, uint8* DataBufferPtr, Eep_LengthType Length);

Eep_SetMode function

Sets the mode.

void Eep_SetMode(MemIf_ModeType Mode);

Eep_Write function

Writes to EEPROM.

Std_ReturnType Eep_Write(Eep_AddressType EepromAddress, const uint8* DataBufferPtr, Eep_LengthType Length);

Eep_AddressType type

Used as address offset from the configured EEPROM base address to access a certain EEPROM memory area.

Eep_ConfigType type

This is the type of the external data structure containing the initialization data for the EEPROM driver.

Eep_LengthType type

Specifies the number of bytes to read/write/erase/compare.

Fee

Fee_Cancel function

Service to call the cancel function of the underlying flash driver.

void Fee_Cancel (void);

Fee_EraseImmediateBlock function

Service to erase a logical block.

Std_ReturnType Fee_EraseImmediateBlock (uint16 BlockNumber);

Fee_GetJobResult function

Service to query the result of the last accepted job issued by the upper layer software.

MemIf_JobResultType Fee_GetJobResult (void);

Fee_GetStatus function

Service to return the status. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_FlashEEPROMEmulation

MemIf_StatusType Fee_GetStatus (void);

Fee_GetVersionInfo function

Service to return the version information of the FEE module.

void Fee_GetVersionInfo (Std_VersionInfoType* VersionInfoPtr);

Fee_Init function

Service to initialize the FEE module.

void Fee_Init (const Fee_ConfigType* ConfigPtr);

Fee_InvalidateBlock function

Service to invalidate a logical block.

Std_ReturnType Fee_InvalidateBlock (uint16 BlockNumber);

Fee_JobEndNotification function

Service to report to this module the successful end of an asynchronous operation. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_FlashEEPROMEmulation

void Fee_JobEndNotification (void);

Fee_JobErrorNotification function

Service to report to this module the failure of an asynchronous operation.

void Fee_JobErrorNotification (void);

Fee_MainFunction function

Service to handle the requested read / write / erase jobs and the internal management operations.

void Fee_MainFunction (void);

Fee_Read function

Service to initiate a read job.

Std_ReturnType Fee_Read (uint16 BlockNumber, uint16 BlockOffset, uint8* DataBufferPtr, uint16 Length);

Fee_SetMode function

Function to switch the mode of the underlying Flash Driver

void Fee_SetMode (MemIf_ModeType Mode);

Fee_Write function

Service to initiate a write job.

Std_ReturnType Fee_Write (uint16 BlockNumber, const uint8* DataBufferPtr);

NvM_JobEndNotification (Fee) function

void NvM_JobEndNotification (void);

NvM_JobErrorNotification (Fee) function

void NvM_JobErrorNotification (void);

Fee_ConfigType type

Configuration data structure of the Fee module.

Fls

Fee_JobEndNotification (Fls) function

This callback function is called when a job has been completed with a positive result.

void Fee_JobEndNotification(void);

Fee_JobErrorNotification (Fls) function

This callback function is called when a job has been canceled or finished with negative result.

void Fee_JobErrorNotification(void);

Fls_BlankCheck function

The function Fls_BlankCheck shall verify, whether a given memory area has been erased but not (yet) programmed. The function shall limit the maximum number of checked flash cells per main function cycle to the configured value FlsMaxReadNormalMode or FlsMaxReadFastMode respectively.

Std_ReturnType Fls_BlankCheck(Fls_AddressType TargetAddress, Fls_LengthType Length);

Fls_Cancel function

Cancels an ongoing job.

void Fls_Cancel(void);

Fls_Compare function

Compares the contents of an area of flash memory with that of an application data buffer.

Std_ReturnType Fls_Compare(Fls_AddressType SourceAddress, const uint8* TargetAddressPtr, Fls_LengthType Length);

Fls_Erase function

Erases flash sector(s).

Std_ReturnType Fls_Erase(Fls_AddressType TargetAddress, Fls_LengthType Length);

Fls_GetJobResult function

Returns the result of the last job.

MemIf_JobResultType Fls_GetJobResult(void);

Fls_GetStatus function

Returns the driver state.

MemIf_StatusType Fls_GetStatus(void);

Fls_GetVersionInfo function

Returns the version information of this module.

void Fls_GetVersionInfo(Std_VersionInfoType* VersioninfoPtr);

Fls_Init function

Initializes the Flash Driver.

void Fls_Init(const Fls_ConfigType* ConfigPtr);

Fls_MainFunction function

Performs the processing of jobs.

void Fls_MainFunction(void);

Fls_Read function

Reads from flash memory.

Std_ReturnType Fls_Read(Fls_AddressType SourceAddress, uint8* TargetAddressPtr, Fls_LengthType Length);

Fls_SetMode function

Sets the flash driver's operation mode.

void Fls_SetMode(MemIf_ModeType Mode);

Fls_Write function

Writes one or more complete flash pages.

Std_ReturnType Fls_Write(Fls_AddressType TargetAddress, const uint8* SourceAddressPtr, Fls_LengthType Length);

Fls_AddressType type

Used as address offset from the configured flash base address to access a certain flash memory area.

Fls_ConfigType type

A pointer to such a structure is provided to the flash driver initialization routine for configuration of the driver and flash memory hardware.

Fls_LengthType type

Specifies the number of bytes to read/write/erase/compare.

FlsTst

FlsTst_Abort function

Service for aborting the Flash Test.

void FlsTst_Abort(void);

FlsTst_DeInit function

Service for Flash Test De - Initialization.

void FlsTst_DeInit(void);

FlsTst_GetVersionInfo function

Service returns the version information of this module.

void FlsTst_GetVersionInfo(Std_VersionInfoType* versioninfo);

FlsTst_Init function

Service for Flash Test initialization.

void FlsTst_Init(const FlsTst_ConfigType* ConfigPtr);

FlsTst_MainFunction function

Service for executing the Flash Test in background mode.

void FlsTst_MainFunction(void);

FlsTst_Resume function

Service for continuing the Flash Test at the point it was suspended.

void FlsTst_Resume(void);

FlsTst_StartFgnd function

Service for executing foreground Flash Test.

Std_ReturnType FlsTst_StartFgnd(FlsTst_BlockIdFgndType FgndBlockId);

FlsTst_Suspend function

Service for suspending current operation of the Flash Test, until Fls Tst_ Resume is called.

void FlsTst_Suspend(void);

FlsTst_TestCompletedNotification function

The function Fls Tst_ Test Completed shall be called every time when a complete test cycle had been tested.

void FlsTst_TestCompletedNotification(void);

FlsTst_TestEcc function

Service executes a test of ECC hardware. This is only applicable in case the hardware provices such functionality.

Std_ReturnType FlsTst_TestEcc(void);

Tst_ErrorDetailsTypeFlsTst_GetErrorDetails function

Service returns error detais monitored from the Flash module.

FlsTst_ErrorDetailsType FlsTst_GetErrorDetails(void);

Tst_StateTypeFlsTst_GetCurrentState function

Service returns the current Flash Test exection state.

FlsTst_StateType FlsTst_GetCurrentState(void);

Tst_TestResultBgndTypeFlsTst_GetTestResultBgnd function

Service returns the Background Flash Test result.

FlsTst_TestResultBgndType FlsTst_GetTestResultBgnd(void);

Tst_TestResultFgndTypeFlsTst_GetTestResultFgnd function

Service returns the Foreground Flash Test result.

FlsTst_TestResultFgndType FlsTst_GetTestResultFgnd(void);

Tst_TestSignatureBgndTypeFlsTst_GetTestSignatureBgnd function

Service returns the Flash Test result in background mode.

FlsTst_TestSignatureBgndType FlsTst_GetTestSignatureBgnd(void);

Tst_TestSignatureFgndTypeFlsTst_GetTestSignatureFgnd function

Service returns the Flash Test result in foreground mode.

FlsTst_TestSignatureFgndType FlsTst_GetTestSignatureFgnd(void);

FlsTst_BlockIdFgndType type

This type specifies the identification (ID) for a Flash block to be tested in foreground mode, which is configured in the configuration structure.

FlsTst_ConfigType type

This type of external data structure shall contain the initialization data for the Flash Test.

FlsTst_ErrorDetailsType type

This type shall specify implementation specific error information monitored in the Flash test module.

FlsTst_StateType type

This is a state value returned by the API service Fls Tst_ Get Current State().

FlsTst_TestResultBgndType type

Return type of API service Fls Tst_ Get Test Result Bgnd().

FlsTst_TestResultFgndType type

Return type of API service Fls Tst_ Get Result Fgnd().

FlsTst_TestResultType type

FlsTst_TestSignatureBgndType type

Type for test signature in background mode.

FlsTst_TestSignatureFgndType type

Type for test signature in foreground mode

Mem

Mem_BlankCheck function

Triggers a job to check the erased state of the page which is referenced by targetAddress. The result of this service can be retrieved using the Mem_GetJobResult API. If the checked page is blank, the result of the job is MEM_JOB_OK. Otherwise, if the page is not blank, the result is MEM_INCONSISTENT.

Std_ReturnType Mem_BlankCheck(Mem_InstanceIdType instanceId, Mem_AddressType targetAddress, Mem_LengthType length);

Mem_DeInit function

De-initialize module. If there is still an access job pending, it is immediately terminated (using hardware cancel operation) and the Mem driver module state is set to unitialized. Therefore, Mem must be re-initialized before it will accept any new job requests after this service is processed.

void Mem_DeInit(void);

Mem_Erase function

Triggers an erase job of the given sector/sector batch defined by targetAddress and length. The result of this service can be retrieved using the Mem_GetJobResult API. If the erase operation was successful, the result of the job is MEM_JOB_OK. If the erase operation failed, e.g. due to a hardware issue, the result of the job is MEM_JOB_FAILED.

Std_ReturnType Mem_Erase(Mem_InstanceIdType instanceId, Mem_AddressType targetAddress, Mem_LengthType length);

Mem_GetJobResult function

Service to return results of the most recent job.

Mem_JobResultType Mem_GetJobResult(Mem_InstanceIdType instanceId);

Mem_GetVersionInfo function

Service to return the version information of the Mem module.

void Mem_GetVersionInfo(Std_VersionInfoType* versionInfoPtr);

Mem_HwSpecificService function

Triggers a hardware specific memory driver job. dataPtr can be used to pass and return data to/ from this service. This service is just a dispatcher to the hardware specific service implementation referenced by hwServiceId. The result of this service can be retrieved using the Mem_GetJobResult API. If the hardware specific operation was successful, the result of the job is MEM_JOB_OK. If the hardware specific operation failed, the result of the job is MEM_JOB_ FAILED. Tags: atp.Status=draft

Std_ReturnType Mem_HwSpecificService(Mem_InstanceIdType instanceId, Mem_HwServiceIdType hwServiceId, Mem_DataType* dataPtr, Mem_LengthType* lengthPtr);

Mem_Init function

Initialization function - initializes all variables and sets the module state to initialized.

void Mem_Init(const Mem_ConfigType* configPtr);

Mem_MainFunction function

Service to handle the requested jobs and the internal management operations.

void Mem_MainFunction(void);

Mem_PropagateError function

This service can be used to report an access error in case the Mem driver cannot provide the access error information - typically for ECC faults. It is called by the system ECC handler to propagate an ECC error to the memory upper layers..

void Mem_PropagateError(Mem_InstanceIdType instanceId);

Mem_Read function

Triggers a read job to copy the from the source address into the referenced destination data buffer. The result of this service can be retrieved using the Mem_GetJobResult API. If the read operation was successful, the result of the job is MEM_JOB_OK. If the read operation failed, the result of the job is either MEM_JOB_FAILED in case of a general error or MEM_ECC_ CORRECTED/MEM_ECC_UNCORRECTED in case of a correctable/uncorrectable ECC error.

Std_ReturnType Mem_Read(Mem_InstanceIdType instanceId, Mem_AddressType sourceAddress, Mem_DataType* destinationDataPtr, Mem_LengthType length);

Mem_Resume function

Resume suspended memory operation using hardware mechanism. Tags: atp.Status=draft

void Mem_Resume(Mem_InstanceIdType instanceId);

Mem_Suspend function

Suspend active memory operation using hardware mechanism. Tags: atp.Status=draft

void Mem_Suspend(Mem_InstanceIdType instanceId);

Mem_Write function

Triggers a write job to store the passed data to the provided address area with given address and length. The result of this service can be retrieved using the Mem_GetJobResult API. If the write operation was successful, the job result is MEM_JOB_OK. If there was an issue writing the data, the result is MEM_FAILED.

Std_ReturnType Mem_Write(Mem_InstanceIdType instanceId, Mem_AddressType targetAddress, const Mem_DataType* sourceDataPtr, Mem_LengthType length);

Mem_AddressType type

Physical memory device address type

Mem_ConfigType type

Postbuild configuration structure type

Mem_DataType type

Read data user buffer type

Mem_HwServiceIdType type

Hardware specific service request identifier type

Mem_InstanceIdType type

Job end notification function called by Mem in case the job processing is configured for job end notification.

Mem_JobResultType type

Asynchronous job result type

Mem_LengthType type

Physical memory device length type

MemAcc

<AddressAreaJobEndNotification> function

MemAcc application job end notification callback. The function name is configurable. Tags: atp.Status=draft

void <AddressAreaJobEndNotification>(MemAcc_AddressAreaIdType addressAreaId, MemAcc_JobResultType jobResult);

<ApplicationLockNotification> function

Address area lock application callback. The function name is configurable. Tags: atp.Status=draft

void <ApplicationLockNotification>(void);

MemAcc_ActivateMem function

Dynamic activation and initialization of a Mem driver referenced by hwId and headerAddress.

Std_ReturnType MemAcc_ActivateMem(MemAcc_AddressType headerAddress, MemAcc_HwIdType hwId);

MemAcc_BlankCheck function

Checks if the passed address space is blank, i.e. erased and writeable. The result of this service can be retrieved using the MemAcc_GetJobResult API. If the address area defined by targetAddress and length is blank, the result is MEMACC_MEM_OK, otherwise the result is MEMACC_MEM_INCONSISTENT.

Std_ReturnType MemAcc_BlankCheck(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType targetAddress, MemAcc_LengthType length);

MemAcc_Cancel function

Triggers a cancel operation of the pending job for the address area referenced by the address AreaId. Cancelling affects only jobs in pending state. For any other states, the request will be ignored.

void MemAcc_Cancel(MemAcc_AddressAreaIdType addressAreaId);

MemAcc_Compare function

Triggers a job to compare the passed data to the memory content of the provided address area. The job terminates, if all bytes matched or a difference was detected. The result of this service can be retrieved using the MemAcc_GetJobResult() API. If the compare operation determined a mismatch, the result code is MEMACC_MEM_INCONSISTENT. Tags: atp.Status=draft

Std_ReturnType MemAcc_Compare(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType sourceAddress, const MemAcc_DataType* dataPtr, MemAcc_LengthType length);

MemAcc_DeactivateMem function

Dynamic deactivation of a Mem driver referenced by hwId and headerAddress.

Std_ReturnType MemAcc_DeactivateMem(MemAcc_HwIdType hwId, MemAcc_AddressType headerAddress);

MemAcc_DeInit function

Deinitialize module. If there are still access jobs pending, they are immediately terminated and the module state is set to unitialized. Therefore, MemAcc must be re-initialized before it will accept any new job requests after this service is processed.

void MemAcc_DeInit(void);

MemAcc_Erase function

Triggers an erase job of the given area. Triggers an erase job of the given area defined by targetAddress and length. The result of this service can be retrieved using the Mem_GetJobResult API. If the erase operation was successful, the result of the job is MEM_JOB_OK. If the erase operation failed, e.g. due to a hardware issue, the result of the job is MEM_JOB_FAILED.

Std_ReturnType MemAcc_Erase(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType targetAddress, MemAcc_LengthType length);

MemAcc_GetJobInfo function

Returns detailed information of the current memory job like memory device ID, job type, job processing state or job result, address area as well as address and length.

void MemAcc_GetJobInfo(MemAcc_AddressAreaIdType addressAreaId, MemAcc_JobInfoType* jobInfoPtr);

MemAcc_GetJobResult function

Returns the consolidated job result of the address area referenced by addressAreaId.

MemAcc_JobResultType MemAcc_GetJobResult(MemAcc_AddressAreaIdType addressAreaId);

MemAcc_GetJobStatus function

Returns the status of the MemAcc job referenced by addressAreaId.

MemAcc_JobStatusType MemAcc_GetJobStatus(MemAcc_AddressAreaIdType addressAreaId);

MemAcc_GetMemoryInfo function

This service function retrieves the physical memory device information of a specific address area. It can be used by an upper layer to get all necessary information to align the start address and trim the length for erase/write jobs.

Std_ReturnType MemAcc_GetMemoryInfo(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType address, MemAcc_MemoryInfoType* memoryInfoPtr);

MemAcc_GetProcessedLength function

Returns the accumulated number of bytes that have already been processed in the current job.

MemAcc_LengthType MemAcc_GetProcessedLength(MemAcc_AddressAreaIdType addressAreaId);

MemAcc_GetVersionInfo function

Service to return the version information of the MemAcc module.

void MemAcc_GetVersionInfo(Std_VersionInfoType* versionInfoPtr);

MemAcc_HwSpecificService function

Triggers a hardware specific job request referenced by hwServiceId. Service specific data can be passed/retrieved by dataPtr. The result of this service can be retrieved using the MemAcc_GetJobResult API. If the hardware specific operation was successful, the result of the job is MEMACC_MEM_OK. If the hardware specific operation failed, the result of the job is MEMACC_MEM_FAILED.

Std_ReturnType MemAcc_HwSpecificService(MemAcc_AddressAreaIdType addressAreaId, MemAcc_HwIdType hwId, MemAcc_MemHwServiceIdType hwServiceId, MemAcc_DataType* dataPtr, MemAcc_LengthType* lengthPtr);

MemAcc_Init function

Initialization function - initializes all variables and sets the module state to initialized.

void MemAcc_Init(const MemAcc_ConfigType* configPtr);

MemAcc_MainFunction function

Service to handle the requested jobs and the internal management operations. Depending on the configuration MemAcc will call the Mem driver main functions.

void MemAcc_MainFunction(void);

MemAcc_Read function

Triggers a read job to copy data from the source address into the referenced destination data buffer. The result of this service can be retrieved using the MemAcc_GetJobResult API. If the read operation was successful, the result of the job is MEMACC_MEM_OK. If the read operation failed, the result of the job is either MEMACC_MEM_FAILED in case of a general error or MEMACC_MEM_ECC_CORRECTED/MEMACC_MEM_ECC_UNCORRECTED in case of a correctable/uncorrectable ECC error.

Std_ReturnType MemAcc_Read(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType sourceAddress, MemAcc_DataType* destinationDataPtr, MemAcc_LengthType length);

MemAcc_ReleaseLock function

Release access lock of provided address area. Tags: atp.Status=draft

Std_ReturnType MemAcc_ReleaseLock(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType address, MemAcc_LengthType length);

MemAcc_RequestLock function

Request lock of an address area for exclusive access. Once the lock is granted, the referenced lock notification function is called by MemAcc.

Std_ReturnType MemAcc_RequestLock(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType address, MemAcc_AddressType length, void* lockNotificationFctPtr);

MemAcc_Write function

Triggers a write job to store the passed data to the provided address area with given address and length. The result of this service can be retrieved using the MemAcc_GetJobResult API. If the write operation was successful, the job result is MEMACC_MEM_OK. If there was an issue writing the data, the result is MEMACC_MEM_FAILED.

Std_ReturnType MemAcc_Write(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType targetAddress, const MemAcc_DataType* sourceDataPtr, MemAcc_LengthType length);

MemAcc_AddressAreaIdType type

Unique address area ID type.

MemAcc_AddressType type

Logical memory address type.

MemAcc_ApplicationLockNotificationType type

Type of the function pointer to register an application callback to be notified once the address area lock was successfully acquired.

MemAcc_ConfigType type

Postbuild configuration structure type.

MemAcc_DataType type

General data type.

MemAcc_HwIdType type

Type for the unique numeric identifiers of all Mem hardware instances used for hardware specific requests.

MemAcc_JobInfoType type

This structure contains information the current processing state of the MemAcc module.

MemAcc_JobResultType type

Asynchronous job result type.

MemAcc_JobStatusType type

Asynchronous job status type.

MemAcc_JobType type

Type for asynchronous jobs.

MemAcc_LengthType type

Job length type.

MemAcc_MemAddressType type

Physical memory device address type

MemAcc_MemBinaryHeaderType type

This structure contains elements for accessing the Mem driver service functions and consistency information. Tags: atp.Status=draft

MemAcc_MemBlankCheckFuncType type

Function pointer for the Mem_BlankCheck service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft

MemAcc_MemConfigType type

Memory driver configuration structure type

MemAcc_MemDataType type

General data type

MemAcc_MemDeInitFuncType type

Function pointer for the Mem_DeInit service for the invocation of the Mem driver API via function pointer interface.

MemAcc_MemEraseFuncType type

Function pointer for the Mem_Erase service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft

MemAcc_MemGetJobResultFuncType type

Function pointer for the Mem_JobResultType service for the invocation of the Mem driver API via function pointer interface.

MemAcc_MemHwServiceIdType type

Index type for Mem driver hardware specific service table.

MemAcc_MemHwSpecificServiceFuncType type

Function pointer for the Mem_HwSpecificService function for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft

MemAcc_MemInitFuncType type

Function pointer for the Mem_Init service for the invocation of the Mem driver API via function pointer interface.

MemAcc_MemInstanceIdType type

Memory driver instance ID type

MemAcc_MemJobResultType type

Asynchronous job result type

MemAcc_MemLengthType type

Physical memory device length type

MemAcc_MemMainFuncType type

Function pointer for the Mem_MainFunction service for the invocation of the Mem driver API via function pointer interface.

MemAcc_MemoryInfoType type

This structure contains information of Mem device characteristics. It can be accessed via the MemAcc_GetMemoryInfo() service. Tags: atp.Status=draft

MemAcc_MemPropagateErrorFuncType type

Function pointer for the Mem_PropagateError service for the invocation of the Mem driver API via function pointer interface.

MemAcc_MemReadFuncType type

Function pointer for the Mem_Read service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft

MemAcc_MemResumeFuncType type

Function pointer for the Mem_Resume service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft

MemAcc_MemSuspendFuncType type

Function pointer for the Mem_Suspend service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft

MemAcc_MemWriteFuncType type

Function pointer for the Mem_Write service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft

MemIf

MemIf_Cancel function

Invokes the "Cancel" function of the underlying memory abstraction module selected by the parameter Device Index.

void MemIf_Cancel (uint8 DeviceIndex);

MemIf_EraseImmediateBlock function

Invokes the "Erase Immediate Block" function of the underlying memory abstraction module selected by the parameter Device Index.

Std_ReturnType MemIf_EraseImmediateBlock (uint8 DeviceIndex, uint16 BlockNumber);

MemIf_GetJobResult function

Invokes the "Get Job Result" function of the underlying memory abstraction module selected by the parameter Device Index. Available v ia Mem If.h

MemIf_JobResultType MemIf_GetJobResult (uint8 DeviceIndex);

MemIf_GetStatus function

Invokes the "Get Status" function of the underlying memory abstraction module selected by the parameter Device Index.

MemIf_StatusType MemIf_GetStatus (uint8 DeviceIndex);

MemIf_GetVersionInfo function

Returns version information.

void MemIf_GetVersionInfo (Std_VersionInfoType* VersionInfoPtr);

MemIf_InvalidateBlock function

Invokes the "Invalidate Block" function of the underlying memory abstraction module AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_MemoryAbstractionInterface selected by the parameter Device Index.

Std_ReturnType MemIf_InvalidateBlock (uint8 DeviceIndex, uint16 BlockNumber);

MemIf_Read function

Invokes the "Read" function of the underlying memory abstraction module selected by the parameter Device Index.

Std_ReturnType MemIf_Read (uint8 DeviceIndex, uint16 BlockNumber, uint16 BlockOffset, uint8* DataBufferPtr, uint16 Length);

MemIf_SetMode function

Invokes the "Set Mode" functions of all underlying memory abstraction modules.

void MemIf_SetMode (MemIf_ModeType Mode);

MemIf_Write function

Invokes the "Write" function of the underlying memory abstraction module selected by the parameter Device Index.

Std_ReturnType MemIf_Write (uint8 DeviceIndex, uint16 BlockNumber, const uint8* DataBufferPtr);

MemIf_JobResultType type

Denotes the result of the last job.

MemIf_ModeType type

Denotes the operation mode of the underlying abstraction mod ules and device drivers.

MemIf_StatusType type

Denotes the current status of the underlying abstraction module and device drive. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_MemoryAbstractionInterface

NvM

NvM_CancelJobs function

Service to cancel all jobs pending for a NV block.

Std_ReturnType NvM_CancelJobs (NvM_BlockIdType BlockId);

NvM_CancelWriteAll function

Service to cancel a running Nv M_ Write All request.

void NvM_CancelWriteAll (void);

NvM_EraseNvBlock function

Service to erase a NV block.

Std_ReturnType NvM_EraseNvBlock (NvM_BlockIdType BlockId);

NvM_FirstInitAll function

The function initiates a multi block first initialization request. The job of the function does not care if a block exists in the non - volatile memory or not OR if it is valid (i.e. not corrupted) or not, when processing it.

void NvM_FirstInitAll (void);

NvM_GetDataIndex function

Service for getting the currently set Data Index of a datase t NVRAM block

Std_ReturnType NvM_GetDataIndex (NvM_BlockIdType BlockId, uint8* DataIndexPtr);

NvM_GetErrorStatus function

Service to read the block dependent error/ status information.

Std_ReturnType NvM_GetErrorStatus (NvM_BlockIdType BlockId, NvM_RequestResultType* RequestResultPtr);

NvM_GetVersionInfo function

Service to get the version information of the Nv M module.

void NvM_GetVersionInfo (Std_VersionInfoType* versioninfo);

NvM_Init function

Service for resetting all internal variables.

void NvM_Init (const NvM_ConfigType* ConfigPtr);

NvM_InitBlockCallbackFunction function

Per block callback routine which shall be called by the Nv M module when default data needs to be restored in RAM, and a RO M block is not configured. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_NVRAMManager

Std_ReturnType NvM_InitBlockCallbackFunction (NvM_InitBlockRequestType InitBlockRequest);

NvM_InvalidateNvBlock function

Service to invalidate a NV block.

Std_ReturnType NvM_InvalidateNvBlock (NvM_BlockIdType BlockId);

NvM_JobEndNotification (NvM) function

Function to be used by the underlying memory abstraction to signal end of job without error.

void NvM_JobEndNotification (void);

NvM_JobErrorNotification (NvM) function

Function to be used by the underlying memory abstraction to signal end of job with error.

void NvM_JobErrorNotification (void);

NvM_MainFunction function

Service for performing the processing of the Nv M jobs.

void NvM_MainFunction (void);

NvM_MultiBlockCallbackFunction function

Common callback routine to notify the upper layer that an asynchronous multi block request has been finished. Available v ia Nv M_ Externals.h

Std_ReturnType NvM_MultiBlockCallbackFunction (NvM_MultiBlockRequestType MultiBlockRequest, NvM_RequestResultType JobResult);

NvM_ReadAll function

Initiates a multi block read request.

void NvM_ReadAll (void);

NvM_ReadBlock function

Service to copy the data of the NV block to its corresponding RAM block.

Std_ReturnType NvM_ReadBlock (NvM_BlockIdType BlockId, void* NvM_DstPtr);

NvM_ReadPRAMBlock function

Service to copy the data of the NV block to its corresponding permanent RAM block.

Std_ReturnType NvM_ReadPRAMBlock (NvM_BlockIdType BlockId);

NvM_ReadRamBlockFromNvm function

Block specific callback routine which shall be called in order to let the application copy data from Nv M module's mirror to RAM block.

Std_ReturnType NvM_ReadRamBlockFromNvm (const void* NvMBuffer);

NvM_RestoreBlockDefaults function

Service to restore the default data to its corr esponding RAM block.

Std_ReturnType NvM_RestoreBlockDefaults (NvM_BlockIdType BlockId, void* NvM_DestPtr);

NvM_RestorePRAMBlockDefaults function

Service to restore the default data to its corresponding permanent RAM block.

Std_ReturnType NvM_RestorePRAMBlockDefaults (NvM_BlockIdType BlockId);

NvM_SetBlockLockStatus function

Service for setting the lock status of a permanent RAM block or of the explicit synchronization of a NVRAM block.

void NvM_SetBlockLockStatus (NvM_BlockIdType BlockId, boolean BlockLocked);

NvM_SetBlockProtection function

Service for setting/ resetting the write protection for a NV block. Availabl e via Nv M.h

Std_ReturnType NvM_SetBlockProtection (NvM_BlockIdType BlockId, boolean ProtectionEnabled);

NvM_SetDataIndex function

Service for setting the Data Inde x of a dataset NVRAM block.

Std_ReturnType NvM_SetDataIndex (NvM_BlockIdType BlockId, uint8 DataIndex);

NvM_SetRamBlockStatus function

Service for setting the RAM block status of a permanent RAM block or the status of the explicit synchronization of a NVRAM block.

Std_ReturnType NvM_SetRamBlockStatus (NvM_BlockIdType BlockId, boolean BlockChanged);

NvM_SingleBlockCallbackFunction function

Per block callback routine to notify the upper layer that an asynchronous single block request has been finished.

Std_ReturnType NvM_SingleBlockCallbackFunction (NvM_BlockRequestType BlockRequest, NvM_RequestResultType JobResult);

NvM_ValidateAll function

Initiates a multi block validation request.

void NvM_ValidateAll (void);

NvM_WriteAll function

Initiates a multi block write request.

void NvM_WriteAll (void);

NvM_WriteBlock function

Service to copy the data of the RAM block to its corresponding NV block. Available vi a Nv M.h

Std_ReturnType NvM_WriteBlock (NvM_BlockIdType BlockId, const void* NvM_SrcPtr);

NvM_WritePRAMBlock function

Service to copy the data of the permanent RAM block to its corresponding NV block.

Std_ReturnType NvM_WritePRAMBlock (NvM_BlockIdType BlockId);

NvM_WriteRamBlockToNvm function

Block specific callback routine which shall be called in order to let the application copy data from RAM block to Nv M module's mirror.

Std_ReturnType NvM_WriteRamBlockToNvm (void* NvMBuffer);

NvM_BlockIdType type

Identification of a NVRAM block via a unique block identifier. Reserved NVRAM block IDs: 0 - > to derive multi block request results via Nv M_ Get Error Status 1 - > redundant NVRAM block which holds the configuration ID

NvM_BlockRequestType type

Identifies the type of reques t performed on a block when signaled via the callback function

NvM_ConfigType type

Configuration data structure of the Nv M module.

NvM_InitBlockRequestType type

Identifies the type of request performed on a block when signaled via the callback function

NvM_MultiBlockRequestType type

Identifies the type of request performed on multi block when signaled via the callback function or when reporting to Bsw M

NvM_RequestResultType type

Type NvM_RequestResultType.

RamTst

RamTst_Allow function

Service for continuing the RAM Test after calling 'Ram Tst_ Stop.

void RamTst_Allow(void);

RamTst_ChangeNumberOfTestedCells function

Service changes the current number of tested cells.

void RamTst_ChangeNumberOfTestedCells(RamTst_NumberOfTestedCellsType NewNumberOfTestedCells);

RamTst_DeInit function

Service for RAM Test deinitialization.

void RamTst_DeInit(void);

RamTst_ErrorNotification function

The function Ram Tst_ Error shall be called every time when a RAM failure has been detected by the selected test algorithm in the background.

void RamTst_ErrorNotification(void);

RamTst_GetVersionInfo function

Service returns the version information of this module.

void RamTst_GetVersionInfo(Std_VersionInfoType* versioninfo);

RamTst_Init function

Service for RAM Test initialization.

void RamTst_Init(const RamTst_ConfigType* ConfigPtr);

RamTst_MainFunction function

Scheduled function for executing the RAM Test in the background.

void RamTst_MainFunction(void);

RamTst_Resume function

Service for allowing to continue the background RAM Test at the point is was suspended.

void RamTst_Resume(void);

RamTst_RunFullTest function

Service for executing the full RAM Test in the foreground.

void RamTst_RunFullTest(void);

RamTst_RunPartialTest function

Service for testing one RAM block in the foreground.

void RamTst_RunPartialTest(RamTst_NumberOfBlocksType BlockId);

RamTst_SelectAlgParams function

Service used to set the test algorithm and its parameter set.

void RamTst_SelectAlgParams(RamTst_AlgParamsIdType NewAlgParamsId);

RamTst_Stop function

Service for stopping the RAM Test.

void RamTst_Stop(void);

RamTst_Suspend function

Service for suspending current operation of background RAM Test, until RESUME is called.

void RamTst_Suspend(void);

RamTst_TestCompletedNotification function

The function Ram Tst_ Test Completed shall be called every time when all RAM blocks of the current test configuration have been tested in the background.

void RamTst_TestCompletedNotification(void);

Tst_AlgorithmTypeRamTst_GetTestAlgorithm function

Service returns the current RAM Test algorithm.

RamTst_AlgorithmType RamTst_GetTestAlgorithm(void);

Tst_AlgParamsIdTypeRamTst_GetAlgParams function

Service returns the ID of the current RAM Test algorithm parameter set.

RamTst_AlgParamsIdType RamTst_GetAlgParams(void);

Tst_ExecutionStatusTypeRamTst_GetExecutionStatus function

Service returns the current RAM Test execution status.

RamTst_ExecutionStatusType RamTst_GetExecutionStatus(void);

Tst_NumberOfTestedCellsTypeRamTst_GetNumberOfTestedCells function

Service returns the current number of tested cells per main - function cycle.

RamTst_NumberOfTestedCellsType RamTst_GetNumberOfTestedCells(void);

Tst_TestResultTypeRamTst_GetTestResult function

Service returns the current RAM Test result.

RamTst_TestResultType RamTst_GetTestResult(void);

Tst_TestResultTypeRamTst_GetTestResultPerBlock function

Service returns the current RAM Test result for the specified block.

RamTst_TestResultType RamTst_GetTestResultPerBlock(RamTst_NumberOfBlocksType BlockID);

RamTst_AlgorithmType type

This is a value returned by the API service Ram Tst_ Get Test Algorithm().

RamTst_AlgParamsIdType type

Data type used to identify a set of configuration parameters for a test algorithm.

RamTst_ConfigType type

Configuration data structure of the Ram Tst module.

RamTst_ExecutionStatusType type

This is a status value returned by the API service Ram Tst_ Get Execution Status().

RamTst_NumberOfBlocksType type

Data type used to identify or count RAM blocks given in the test configuration parameters.

RamTst_NumberOfTestedCellsType type

Data type of number of tested RAM cells

RamTst_TestResultType type

This is a status value returned by the API service Ram Tst_ Get Test Result().

Click an entry to see its relations.

Cluster guideAI-GENERATED

Saves and manages persistent data independently of hardware via structured NVRAM blocks and abstraction drivers.

AI-GENERATED unreviewed Model: gemini-3.8-flash-medium · Effort: medium · Temperature: not controllable · Prompt: 34f2477a24b6 Provenance Open questions (1)

translated from the German guidegemini-3.8-flash-low · 2026-10-13 · German original

Saves and manages persistent data independently of hardware via structured NVRAM blocks and abstraction drivers.

The module cluster 'Memory Services' realizes the hardware-independent storage and consistency assurance of non-volatile application data via the NVRAM Manager as well as the hardware-abstracting modules MemIf, Fee, and Ea ([SWS_NvM_00447], [SWS_MemIf_00039]). Asynchronous read and write operations are processed via cyclic MainFunctions and executed in batches during ECU startup (NvM_ReadAll) as well as during shutdown (NvM_WriteAll) ModemanagementGuide p. 54. In the event of hardware errors, multi-level retry, redundancy, and ROM restoration mechanisms take effect with automatic reporting to the DEM ([SWS_NvM_00470]).

The cluster 'Memory Services' provides the persistent storage and management of non-volatile data in the AUTOSAR Classic BSW stack. It comprises the NVRAM Manager ([SWS_NvM_00447]) at the service layer as well as the Memory Abstraction Interface ([SWS_MemIf_00039]) with the modules Flash EEPROM Emulation ([SWS_Fee_00085]) and EEPROM Abstraction ([SWS_Ea_00083]) at the hardware abstraction layer AUTOSAR SWS NVRAMManager p. 10.

Architecture diagram: Layered structure and module relationships in the Memory Services cluster. Sources: [SWS_MemIf_00039], AUTOSAR SWS NVRAMManager p. 10

Data exchange takes place via synchronous control APIs and asynchronous write and read jobs. Data is exchanged either implicitly via permanent RAM blocks or explicitly via module-managed RAM mirrors ([SWS_NvM_00455], [SWS_NvM_00514]) NVDataHandling p. 12. The cyclic processing of queued jobs is performed via periodically executed BSW main functions (NvM_MainFunction, Fee_MainFunction), while MemIf delegates calls statelessly to the underlying drivers ([SWS_MemIf_00040]) AUTOSAR CP SWS FlashEEPROMEmulation p. 42.

In the operating cycle, BswM coordinates multi-block actions: During system startup, NvM_ReadAll reads persistent data from NV memory into RAM ([SWS_NvM_00460]), while during shutdown, NvM_WriteAll saves modified data ([SWS_NvM_00461]) ModemanagementGuide p. 54. Erroneous read or write accesses are intercepted by retry attempts as well as redundant copies or ROM fallback values; permanent errors are reported by the system to DEM ([SWS_NvM_00470], [SWS_NvM_00279]) ErrorDescription p. 62.

System Architecture & Role of the Module Cluster

The memory services module cluster (Memory Services) of the AUTOSAR Classic Platform ensures the standardized, hardware-independent management and persistence of application and Basic Software data in non-volatile memory. The cluster is vertically structured into two layers of the AUTOSAR Basic Software architecture: the NVRAM Manager ([SWS_NvM_00447]) at the service layer (Services Layer) and the Memory Abstraction Interface ([SWS_MemIf_00039]) with the underlying abstraction modules Flash EEPROM Emulation ([SWS_Fee_00085]) and EEPROM Abstraction ([SWS_Ea_00083]) at the hardware abstraction layer (Memory Hardware Abstraction Layer) AUTOSAR SWS NVRAMManager p. 10.

The NVRAM Manager (NvM) forms the central entry point for software components (SW-C) and BSW modules such as the Diagnostic Event Manager module (Dem) SWS DiagnosticEventManager p. 238. It manages logical memory blocks composed of NV blocks in non-volatile memory, RAM blocks in volatile memory, and optional ROM blocks for initialization data ([SWS_NvM_00137], [SWS_NvM_00128]). Depending on requirements, the block management types native (NVM_BLOCK_NATIVE), redundant (NVM_BLOCK_REDUNDANT), or dataset (NVM_BLOCK_DATASET) are supported AUTOSAR CP RS MemoryServices p. 10.

The modules Fee and Ea encapsulate the specifics of the respective physical storage media (Flash and EEPROM, respectively) and map logical block numbers and address offsets to the linear address spaces of the respective MCAL drivers (Fls and Eep, respectively) ([SWS_Fee_00087], [SWS_Ea_00086]) AUTOSAR SWS EEPROMAbstraction p. 23. The module MemIf serves as a pure routing layer that forwards accesses to the target module based on the parameter DeviceIndex, without maintaining buffer structures of its own ([SWS_MemIf_00040]).

Architecture diagram: Layered structure and module relationships in the Memory Services cluster. Sources: [SWS_MemIf_00039], AUTOSAR SWS NVRAMManager p. 10

Interplay & Interaction Paths Between the Modules

Interaction between the modules takes place via strictly standardized synchronous and asynchronous paths. If a user initiates a write operation via NvM_WriteBlock, the request is first registered in the administrative block of NvM ([SWS_NvM_00455]). In the case of a synchronous call, it is forwarded to MemIf via MemIf_Write ([SWS_MemIf_00040]), which passes the call to Fee_Write or Ea_Write ([SWS_Fee_00088], [SWS_Ea_00087]) AUTOSAR SWS NVRAMManager p. 160.

Regarding data management and synchronization between the application and the NVRAM Manager, two core concepts exist: implicit synchronization via permanent RAM blocks (NvMRamBlockDataAddress) and explicit synchronization via mirror-based buffers (NvMBlockUseSyncMechanism) NVDataHandling p. 12. In the case of explicit synchronization, NvM copies payload data between application RAM and the internal RAM mirror via the configured callback routines NvMWriteRamBlockToNvCallback and NvMReadRamBlockFromNvCallback, respectively ([SWS_NvM_00514], [SWS_NvM_00515]) EXP NVDataHandling p. 30.

When using dataset blocks (NVM_BLOCK_DATASET), the caller selects the desired dataset index in advance via NvM_SetDataIndex ([SWS_NvM_00448]). The abstraction modules then calculate the exact address offset for the MCAL driver from the logical block number and the index ([SWS_NvM_00123]) AUTOSAR SWS Flash EEPROM Emulation p. 21. Cancellation requests are passed through directly to the submodules Fee_Cancel and Ea_Cancel, respectively, via MemIf_Cancel ([SWS_MemIf_00041], [SWS_Fee_00089]).

Sequence diagram: Asynchronous write job with callback notification and polling. Sources: [SWS_NvM_00455], AUTOSAR SWS NVRAMManager p. 160

Synchronization, reentrancy and task contexts

Most control and status APIs of the cluster, including NvM_GetErrorStatus ([SWS_NvM_00451]), NvM_SetBlockProtection ([SWS_NvM_00450]), and MemIf_GetVersionInfo ([SWS_MemIf_00045]), are synchronous and can be processed directly in the caller's task context AUTOSAR SWS NVRAMManager p. 157. In contrast, the data-transferring functions (NvM_ReadBlock, NvM_WriteBlock, Ea_Write) are designed to be asynchronous and non-reentrant ([SWS_MemIf_00040], [SWS_Ea_00087]).

The cyclic progression of ongoing jobs is the responsibility of the main functions NvM_MainFunction and Fee_MainFunction, which are called periodically by the Schedule Manager (SchM) or a BSW task AUTOSAR CP SWS FlashEEPROMEmulation p. 42. For asynchronous notifications from the MCAL driver, the notification Fee_JobEndNotification or Fee_JobErrorNotification can occur directly at interrupt level ([SWS_Fee_00095]). This sets the status to MEMIF_JOB_OK or calls configured notification routines ([SWS_Fee_00142], [SWS_Fee_00194]) SWS FlashEEPROMEmulation p. 37.

Interpretation: To prevent race conditions between API callers at task level and the incremental further processing in the MainFunctions, internal queues and administrative attributes are likely protected by exclusive areas, while MemIf acts as a stateless forwarding layer AUTOSAR SWS NVRAMManager p. 160. Question Q-a50c3362a14b9e6d (open)

Typical lifecycles and operating modes

The lifecycle of the cluster is tightly orchestrated by the Basic Software Mode Manager (BswM) and the ECU State Manager (EcuM). During ECU startup (Startup Phase), after the drivers, first the abstraction modules are initialized synchronously via Fee_Init and Ea_Init, respectively ([SWS_Fee_00085], [SWS_Ea_00083]), and subsequently the NVRAM Manager via NvM_Init ([SWS_NvM_00447]) AUTOSAR SWS NVRAMManager p. 156.

Following initialization, BswM triggers the multi-block read operation NvM_ReadAll to restore all RAM blocks marked as persistent from non-volatile memory ([SWS_NvM_00460]) ModemanagementGuide p. 54. NvM reports the progress and the final result back to BswM via the callback function BswM_NvM_CurrentJobMode ([SWS_NvM_00745], [SWS_NvM_00888]). Individual block states are signaled via BswM_NvM_CurrentBlockMode ([SWS_NvM_00746], [SWS_NvM_00890]) ModemanagementGuide p. 28.

In the shutdown phase, the system initiates the persistent write-back of all modified RAM blocks into NV memory via NvM_WriteAll ([SWS_NvM_00461]). In order to optimize the number of flash write cycles, whether a block has been modified can be selectively marked via NvM_SetRamBlockStatus ([SWS_NvM_00453]) EXP NVDataHandling p. 18. In the event of premature wake-up events, an ongoing write operation can be canceled via NvM_CancelWriteAll ([SWS_NvM_00238]) AUTOSAR SWS NVRAMManager p. 161.

Error Handling, DET Tracing, and Degradation

The cluster features a multi-level fault detection and degradation concept. Errors occurring at driver and abstraction levels are queried via the return status MEMIF_JOB_FAILED using MemIf_GetJobResult or reported via NvM_JobErrorNotification ([SWS_Fee_00091], [SWS_Ea_00095]) ErrorDescription p. 49.

When read errors occur, NvM resorts to configured recovery mechanisms: First, retries (Read Retries) are attempted ([SWS_NvM_00390]). If these fail, the redundant copy is read in the case of redundant blocks (NVM_BLOCK_REDUNDANT) ([SWS_NvM_00171], [SWS_NvM_00531]). If a loss of redundancy is detected in this process, NvM sets the job result to NVM_REQ_REDUNDANCY_FAILED and reports the production error NVM_E_LOSS_OF_REDUNDANCY to DEM ([SWS_NvM_00470], [SWS_NvM_00546]) ErrorDescription p. 62.

If recovery via ROM default values succeeds, the NvM reports the result NVM_REQ_RESTORED_FROM_ROM ([SWS_NvM_00470]). If all recovery actions fail, NVM_E_REQ_FAILED is reported to the DEM ([SWS_NvM_00279], [SWS_NvM_00288]) and the query result is set to NVM_REQ_NOT_OK ([SWS_NvM_00451]). In the event of write errors, the NvM controls write retries (NvMMaxNumOfWriteRetries) before the request is aborted ([SWS_NvM_00168], [SWS_NvM_00213]) ErrorDescription p. 56.

This guide summarizes the core architecture, module interactions, and error mechanisms of the Memory Services cluster. All statements are based on the normative specifications of the AUTOSAR Classic Platform.

AUTOSAR Classic Memory Services

Topic map

Detail view

Cluster guideAI-GENERATED🔍

System Architecture & Role of the Module Cluster

Interplay & Interaction Paths Between the Modules

Synchronization, reentrancy and task contexts

Typical lifecycles and operating modes

Error Handling, DET Tracing, and Degradation

Module im Cluster

Bulk NvData Manager (BndM)

EEPROM Abstraction (Ea)

EEPROM Driver (Eep)

Flash EEPROM Emulation (Fee)

Flash Driver (Fls)

Flash Test (FlsTst)

Memory Driver (Mem)

Memory Access (MemAcc)

Memory Abstraction Interface (MemIf)

NVRAM Manager (NvM)

RAM Test (RamTst)

Cluster guideAI-GENERATED