NVRAM Manager (NvM)

Verwendung und Aufrufkontext

Die Funktion NvM_Init dient dem synchronen Zurücksetzen aller internen Variablen des NVRAM Managers [SWS_NvM_00447]. Sie erwartet als Übergabeparameter ConfigPtr einen Zeiger auf den ausgewählten Konfigurationsdatensatz und besitzt keinen Rückgabewert [SWS_NvM_00447]. Als API vom Typ 4 ist sie Bestandteil der Konfigurationsklassen 2 und 3 [SWS_NvM_00560], [SWS_NvM_00561]. Die Funktion ist nicht reentrant und darf ausschließlich durch den BSW Mode Manager aufgerufen werden [SWS_NvM_00447], [SWS_NvM_00693].

Initialisierungsaufgaben

Während des Aufrufs führt die Funktion folgende Aktionen aus:

• Rücksetzen aller internen Variablen, darunter Zustandsmaschinen, Auftrags-Queues und Request-Flags, auf ihre Initialwerte [SWS_NvM_00399].
• Setzen des Datensatz-Index aller NVRAM-Blöcke vom Typ NVM_BLOCK_DATASET auf null [SWS_NvM_00192].
• Internes Setzen des Signals „INIT DONE“, welches die Voraussetzung für die Auftragsverarbeitung, das Queue-Management und die CRC-Neuberechnung im Modul darstellt [SWS_NvM_00257], [SWS_NvM_00399].

Einschränkungen und Zusammenspiel

Wegen strikter Anforderungen an die Startzeit des Steuergeräts initialisiert NvM_Init keine konfigurierten NVRAM-Blöcke [SWS_NvM_00091]. Permanente RAM-Blockinhalte werden nicht verändert und Synchronisations-Callbacks nicht aufgerufen; dies ist der Funktion NvM_ReadAll vorbehalten [SWS_NvM_00400]. Zudem initialisiert NvM_Init weder unterlagerte Treiber noch die Speicher-Hardware-Abstraktion oder fremde Module, da deren Initialisierung durch den BSW Mode Manager vorausgesetzt wird [SWS_NvM_00157], [SWS_NvM_00193].

Verwendung und Semantik

Die synchrone und reentrante Funktion NvM_SetBlockProtection dient dem Setzen oder Zurücksetzen des Schreibschutzes für einen NVRAM-Block über das entsprechende Attribut im administrativen Block [SWS_NvM_00450], [SWS_NvM_00016]. Sie ist der API-Konfigurationsklasse 3 zugeordnet [SWS_NvM_00560]. Die Umgebung des NvM-Moduls kann den Schreibschutz über den Parameter ProtectionEnabled gezielt aktivieren oder deaktivieren [SWS_NvM_00578]. Die Funktion liefert bei erfolgreicher Ausführung E_OK und im Fehlerfall E_NOT_OK zurück [SWS_NvM_00450].

Einschränkungen und Nebenläufigkeit

Das Ändern des Schreibschutzes ist nur für Blöcke zulässig, bei denen NvMWriteBlockOnce auf FALSE konfiguriert ist, unabhängig vom Wert des Parameters NvMBlockWriteProt [SWS_NvM_00325]. Ist NvMWriteBlockOnce auf TRUE konfiguriert, darf der Schreibschutz weder aktiviert noch deaktiviert werden [SWS_NvM_00398], [SWS_NvM_00577]; dieser Schutz kann auch nach Leseoperationen nicht aufgehoben werden [SWS_NvM_00314], [SWS_NvM_00316], [SWS_NvM_00784]. Zudem kann ein über NvM_SetBlockLockStatus gesetzter Sperrzustand nicht durch NvM_SetBlockProtection modifiziert werden [SWS_NvM_00754]. Solange ein Einzelblockauftrag für denselben Block aktiv oder eingereiht ist, ist der Aufruf nicht zulässig [SWS_NvM_00704].

Fehlerbehandlung

Bei aktivierter Entwicklungserkennung (DET) meldet die Funktion spezifische Fehlerzustände:

• NVM_E_UNINIT, wenn das NvM-Modul noch nicht initialisiert ist [SWS_NvM_00606].
• NVM_E_PARAM_BLOCK_ID, wenn die übergebene BlockId außerhalb des gültigen Bereichs liegt [SWS_NvM_00609].
• NVM_E_BLOCK_PENDING, falls für den Block bereits ein Vorgang aktiv oder eingereiht ist [SWS_NvM_00607].
• NVM_E_BLOCK_CONFIG, wenn der Block mit NvMWriteBlockOnce = TRUE konfiguriert ist [SWS_NvM_00608].
• NVM_E_BLOCK_LOCKED, wenn der Block gesperrt ist [SWS_NvM_00759].

Die synchrone und reentrante Funktion NvM_SetRamBlockStatus dient dem Setzen des RAM-Block-Status für permanente RAM-Blöcke oder für Blöcke mit expliziter Synchronisation [SWS_NvM_00453]. Sie steht in den API-Konfigurationsklassen 2 und 3 zur Verfügung [SWS_NvM_00561], [SWS_NvM_00560], sofern sie über den Konfigurationsparameter NvMSetRamBlockStatusApi aktiviert wurde [SWS_NvM_00408].

Über den Parameter BlockChanged wird gesteuert, ob der Block als gültig und verändert (TRUE) oder als ungültig und unverändert (FALSE) markiert wird [SWS_NvM_00453], [SWS_NvM_00406]. Bei Übergabe von TRUE geht das Modul von der Gültigkeit der Daten aus [SWS_NvM_00241]. Die Funktion liefert E_OK bei erfolgreicher Statusänderung und E_NOT_OK im Fehlerfall zurück [SWS_NvM_00453].

Wird BlockChanged auf TRUE gesetzt, fordert die Funktion im Hintergrund eine Neuberechnung der Prüfsumme in NvM_MainFunction an, falls NvMCalcRamBlockCrc konfiguriert ist [SWS_NvM_00121]. Bei Blöcken ohne permanenten RAM mit expliziter Synchronisation nutzt dieser Job den Schreib-Callback zur Datenbeschaffung [SWS_NvM_00906]. Schlägt dieser fehl, erfolgen konfigurierte Wiederholungen pro Aufruf von NvM_MainFunction [SWS_NvM_00907], [SWS_NvM_00908]. Bleiben alle Versuche erfolglos, gilt der Job dennoch als beendet und der Block bleibt als geändert markiert [SWS_NvM_00909].

Vor dem Aufruf muss das NvM-Modul initialisiert sein [SWS_NvM_00711]. Bei aktiver Entwicklungsausstandserkennung meldet die Funktion NVM_E_UNINIT bei uninitialisiertem Modul [SWS_NvM_00643], NVM_E_PARAM_BLOCK_ID bei ungültiger BlockId [SWS_NvM_00645] und NVM_E_BLOCK_PENDING bei bereits laufenden oder eingereihten Aufträgen [SWS_NvM_00644]. Solange ein Einzelblock-Auftrag aktiv ist, darf die Funktion für diesen Block nicht aufgerufen werden [SWS_NvM_00704]. Eine über NvM_SetBlockLockStatus gesetzte Blocksperre kann hierüber nicht verändert werden [SWS_NvM_00754].

Verwendung und Aufrufkontext

Die synchrone und reentrante Funktion NvM_SetBlockLockStatus dient dem Sperren (BlockLocked = TRUE) oder Entsperren (BlockLocked = FALSE) eines permanent konfigurierten RAM-Blocks oder der expliziten Synchronisation eines NVRAM-Blocks [SWS_NvM_00548]. Sie gehört zum Funktionsumfang der API-Konfigurationsklassen 2 und 3 [SWS_NvM_00561], [SWS_NvM_00560]. Die Funktion ist nicht im ServicePort-Interface enthalten und wird primär durch das DCM sowie durch komplexe Gerätetreiber (CDD) aufgerufen [SWS_NvM_00732].

Einschränkungen und Zusammenspiel

Der Aufruf wirkt ausschließlich auf NVRAM-Blöcke mit permanentem RAM-Block oder konfigurierter expliziter Synchronisation; bei allen anderen Blöcken bleibt er ohne Effekt [SWS_NvM_00732]. Wird ein Block gesperrt (BlockLocked = TRUE), stellt das NvM sicher, dass die zugeordneten NV-Daten nicht modifiziert werden: Der Block wird bei NvM_WriteAll übersprungen, und die Dienste NvM_WriteBlock, NvM_WritePRAMBlock, NvM_InvalidateNvBlock sowie NvM_EraseNvBlock werden abgewiesen [SWS_NvM_00751]. Beim nächsten Hochlauf lädt das NvM den Block bei NvM_ReadBlock oder NvM_ReadPRAMBlock garantiert aus dem NV-Speicher [SWS_NvM_00752]. Der gesetzte Sperrzustand kann weder über NvM_SetRamBlockStatus noch über NvM_SetBlockProtection modifiziert werden [SWS_NvM_00754]. Die Übergabe von BlockLocked = FALSE stellt die reguläre Bearbeitung wieder her [SWS_NvM_00753].

Fehlerbehandlung

Bei aktivierter Entwicklungserkennung (DET) meldet die Funktion spezifische Entwicklungsfehler:

• NVM_E_UNINIT, falls das NvM-Modul zum Aufrufzeitpunkt noch nicht initialisiert ist [SWS_NvM_00728].
• NVM_E_PARAM_BLOCK_ID, wenn der Parameter BlockId außerhalb des zulässigen Bereichs liegt [SWS_NvM_00731].
• NVM_E_BLOCK_CONFIG, sofern der referenzierte NVRAM-Block mit dem Parameter NvMWriteBlockOnce = TRUE konfiguriert ist [SWS_NvM_00730].

Verwendung und Semantik

Die über NvM.h verfügbare Funktion NvM_CancelJobs dient dazu, alle in der Warteschlange anstehenden Aufträge für einen bestimmten NVRAM-Block synchron abzubrechen [SWS_NvM_00535], [SWS_NvM_00536]. Die Funktion ist reentrant ausgelegt und erwartet als Parameter die BlockId, welche den Block-Deskriptor des betreffenden NVRAM-Blocks eindeutig identifiziert [SWS_NvM_00535]. Der Aufruf liefert E_OK zurück, wenn anstehende Aufträge erfolgreich aus der Warteschlange entfernt werden konnten, und E_NOT_OK, falls für den angegebenen Block kein Auftrag in der Warteschlange auffindbar war [SWS_NvM_00535].

Ablauf und Nebenläufigkeit

Ein Auftrag, der zum Zeitpunkt des Funktionsaufrufs bereits aktiv abgearbeitet wird, wird durch NvM_CancelJobs nicht unterbrochen, sondern läuft bis zum Ende weiter [SWS_NvM_00537]. Sofern die Abbruchanforderung für wartende Aufträge akzeptiert wird, setzt der Dienst das blockspezifische Anfrageergebnis vorab auf NVM_REQ_CANCELED [SWS_NvM_00225], [SWS_NvM_00536]. Zweck dieser Bereinigung ist es, die Warteschlange beispielsweise bei Terminierung oder Neustart einer Partition zu leeren und so spätere Benachrichtigungen über abgeschlossene Jobs zu unterbinden [SWS_NvM_00225].

Fehlerbehandlung und Konfiguration

Bei aktivierter Entwicklungserkennung (DET) prüft die Funktion die Vorbedingungen: Ist das Modul noch uninitialisiert, wird der Fehler NVM_E_UNINIT gemeldet [SWS_NvM_00648]. Liegt die übergebene BlockId außerhalb des gültigen Bereichs, erfolgt die DET-Meldung NVM_E_PARAM_BLOCK_ID [SWS_NvM_00649]. NvM_CancelJobs ist als Typ-2-API eingestuft und steht in den API-Konfigurationsklassen 2 und 3 zur Verfügung [SWS_NvM_00561], [SWS_NvM_00560].

Verwendung und Semantik

Die Funktion NvM_ReadBlock dient dem asynchronen Kopieren von Nutzdaten aus dem NV-Speicher in den zugehörigen RAM-Block [SWS_NvM_00010], [SWS_NvM_00454]. Der Aufruf ist reentrant [SWS_NvM_00454]. Er übernimmt die Parameter, reiht den Leseauftrag in die interne Job-Queue ein und gibt unmittelbar E_OK bei erfolgreicher Annahme bzw. E_NOT_OK bei Ablehnung zurück [SWS_NvM_00195], [SWS_NvM_00454].

Wird ein Zeiger NvM_DstPtr übergeben, können Daten abweichend von der Blockkonfiguration in einen temporären RAM-Puffer gelesen werden; ein unzulässiger NULL-Zeiger führt in diesem Szenario zu einem DET-Fehler [SWS_NvM_00196], [SWS_NvM_00278]. Ein konfigurierter permanenter RAM-Block wird direkt beim Einreihen oder bei Start der Jobverarbeitung als ungültig markiert [SWS_NvM_00198]. Erst nach erfolgreichem Kopiervorgang gilt der RAM-Block als gültig sowie unverändert [SWS_NvM_00200], und das Auftragsergebnis wechselt auf NVM_REQ_OK [SWS_NvM_00206].

Fehlerbehandlung und Datenintegrität

Ist für den Block eine Prüfsumme aktiviert (NvMCalRamBlockCrC == TRUE), fordert der Job nach dem Kopieren eine Neuberechnung an [SWS_NvM_00201]:

• Bei CRC-Fehlern wird NVM_E_INTEGRITY_FAILED an das DEM gemeldet [SWS_NvM_00203]. Sofern vorhanden, werden Standardwerte geladen und das Ergebnis auf NVM_REQ_RESTORED_DEFAULTS gesetzt [SWS_NvM_00202]. Fehlen ROM-Daten und Initialisierungs-Callbacks, resultiert NVM_REQ_INTEGRITY_FAILED [SWS_NvM_00204].
• Meldet der Speichertreiber MEMIF_JOB_FAILED und sind keine Ersatzwerte verfügbar, endet der Auftrag mit NVM_REQ_NOT_OK [SWS_NvM_00359].

Besonderheiten der Blocktypen

• Redundant: Schlägt das Lesen der ersten Kopie fehl, wird automatisch die zweite NV-Kopie herangezogen [SWS_NvM_00199]. Sind beide Kopien ungültig, wird der Gesamtblock invalidiert [SWS_NvM_00317].
• Dataset: Ist der über den Datensatz-Index selektierte Block als ungültig markiert, unterbleibt das Kopieren in das RAM [SWS_NvM_00355].
• Write-Once: Konsistent gelesene Blöcke mit gesetztem NVM_WRITE_BLOCK_ONCE werden dauerhaft schreibgeschützt [SWS_NvM_00316].

Die Funktion NvM_WriteBlock dient dem Kopieren von Daten eines RAM-Blocks in den zugeordneten NV-Block [SWS_NvM_00455], [SWS_NvM_00410]. Der Aufruf wird reentrant und asynchron ausgeführt: Die Funktion übernimmt die übergebenen Parameter BlockId sowie NvM_SrcPtr, reiht den Schreibauftrag in die interne Job-Warteschlange ein und kehrt unmittelbar zurück [SWS_NvM_00208]. Der Rückgabewert signalisiert mit E_OK die erfolgreiche Annahme oder mit E_NOT_OK die Abweisung des Auftrags [SWS_NvM_00455].

Hinsichtlich Parametrierung und Datenquelle gelten folgende Vorgaben:

• Wird eine gültige RAM-Adresse über NvM_SrcPtr übergeben, nutzt der Schreibauftrag diesen Puffer [SWS_NvM_00210]. Dies erlaubt auch das Sichern temporärer RAM-Blöcke bei eigentlich permanent konfigurierten Blöcken oder expliziter Synchronisation [SWS_NvM_00280].
• Ein konfigurierter permanenter RAM-Block wird als gültig vorausgesetzt oder vor dem Kopiervorgang automatisch validiert [SWS_NvM_00303].
• Ist für den NV-Block eine Prüfsumme konfiguriert, fordert der Job vor dem Schreibvorgang eine CRC-Neuberechnung an [SWS_NvM_00212].
• Bei Datensatz-Blöcken (NVM_BLOCK_DATASET) wird das Ziel über den im administrativen Block hinterlegten Datenindex ausgewählt [SWS_NvM_00338].
• Bei redundanten Blöcken (NVM_BLOCK_REDUNDANT) schließt der Job mit NVM_REQ_OK ab, sobald mindestens eine Kopie erfolgreich geschrieben wurde [SWS_NvM_00284].
• Ist NvMWriteBlockOnce == TRUE gesetzt, aktiviert der Job nach erfolgreichem Schreiben umgehend den Schreibschutz im administrativen Block [SWS_NvM_00328].
• Schreibaufträge für die reservierte Block-ID 1 sind nur bei aktiviertem NvMDynamicConfiguration zulässig [SWS_NvM_00311].

Fehlerbehandlung und Nebenläufigkeit:

• Ist die Entwicklungserkennung aktiv, meldet NvM_WriteBlock den DET-Fehler NVM_E_UNINIT bei uninitialisiertem Modul [SWS_NvM_00619] sowie NVM_E_BLOCK_PENDING, falls derselbe Block bereits in Bearbeitung oder eingereiht ist [SWS_NvM_00620]. Ein fehlender Quellzeiger bei temporären Puffern führt zu einem DET-Parameterfehler [SWS_NvM_00280].
• Negative Rückmeldungen der Speicherschnittstelle erhöhen den Wiederholungszähler; nach Überschreiten von NVM_MAX_NUM_OF_WRITE_RETRIES endet der Job mit NVM_REQ_NOT_OK [SWS_NvM_00213], [SWS_NvM_00216].
• Ist der Block mit Sofortpriorität konfiguriert, bricht NvM_WriteBlock einen aktuell laufenden Job destruktiv ab, damit der Schreibauftrag als nächstes verarbeitet wird [SWS_NvM_00300].

Verwendung und Semantik

Die Funktion NvM_RestoreBlockDefaults stellt Standarddaten in dem zugeordneten RAM-Block wieder her ([SWS_NvM_00456], [SWS_NvM_00012]). Sie arbeitet asynchron: Nach dem Aufruf übernimmt sie die Parameter, reiht die Anforderung in die interne Auftragswarteschlange ein und kehrt unmittelbar mit E_OK bei erfolgreicher Annahme oder mit E_NOT_OK bei Ablehnung zurück ([SWS_NvM_00456], [SWS_NvM_00224]). Wird über den Ausgabeparameter NvM_DestPtr eine gültige RAM-Adresse übergeben, wird diese als Zieladresse verwendet ([SWS_NvM_00435]). Um ROM-Daten in einen temporären RAM-Block zu kopieren, obwohl ein permanenter RAM-Block oder Synchronisations-Callbacks konfiguriert sind, muss der Aufrufer zwingend einen Zeiger ungleich NULL übergeben ([SWS_NvM_00436]).

Fehlerbehandlung und Randbedingungen

Die Funktion ist nicht reentrant ([SWS_NvM_00456]) und Teil der API-Konfigurationsklassen 2 und 3 ([SWS_NvM_00561], [SWS_NvM_00560]). Ist die Entwicklungserkennung (DET) aktiv, meldet sie NVM_E_UNINIT, falls das Modul noch uninitialisiert ist ([SWS_NvM_00625]), NVM_E_PARAM_BLOCK_ID bei ungültiger BlockId ([SWS_NvM_00630]) sowie einen Parameterfehler, wenn bei permanent konfigurierten Blöcken für temporäres Kopieren kein gültiger Zielzeiger übergeben wird ([SWS_NvM_00436]). Die Funktion schlägt synchron mit E_NOT_OK fehl, wenn der Block vom Typ NVM_BLOCK_DATASET ist, mindestens ein ROM-Block existiert und der aktuelle Datenindex auf einen NV-Block zeigt ([SWS_NvM_00353]).

Job-Verarbeitung und Zusammenspiel

Im Rahmen der asynchronen Auftragsverarbeitung lädt der Dienst Standardwerte aus einem konfigurierten ROM-Block ([SWS_NvM_00267]). Ist ein permanenter RAM-Block angefordert oder kommt ein expliziter Synchronisations-Callback (NvMReadRamBlockFromNvCallback) zum Einsatz, wird der RAM-Block vor dem Kopiervorgang bzw. vor dem Callback-Aufruf invalidiert ([SWS_NvM_00227]). Nach erfolgreichem Kopiervorgang oder nach Rückkehr des Synchronisations-Callbacks mit E_OK wird der RAM-Block validiert und als geändert markiert ([SWS_NvM_00228]). Ist für den Block eine Prüfsumme konfiguriert, fordert der Job abschließend eine CRC-Neuberechnung an ([SWS_NvM_00229]). Dieselbe Wiederherstellungslogik nutzen auch NvM_ReadBlock und NvM_ReadAll als Ausweichmechanismus bei fehlerhaftem Speicherlesezugriff oder CRC-Fehlern ([SWS_NvM_00202], [SWS_NvM_00293], [SWS_NvM_00657]).

Die reentrante, asynchrone Funktion NvM_EraseNvBlock ([SWS_NvM_00457]) der API-Konfigurationsklasse 3 ([SWS_NvM_00560]) dient dem Löschen eines nichtflüchtigen Speicherblocks anhand der übergebenen BlockId. Sofern kein Schreibschutz aktiv ist, übernimmt die Funktion die Parameter, reiht den Löschauftrag in die interne Auftragswarteschlange ein und kehrt unmittelbar zurück ([SWS_NvM_00231], [SWS_NvM_00418]). Der Rückgabewert E_OK signalisiert die erfolgreiche Annahme des Auftrags, während E_NOT_OK die Zurückweisung anzeigt ([SWS_NvM_00457]).

Vor dem Aufruf muss das NvM-Modul vollständig initialisiert sein ([SWS_NvM_00715]). Nach dem Einreihen wird der Schreibschutz vor Entnahme des Jobs aus der Warteschlange nicht erneut geprüft ([SWS_NvM_00662]). Bei redundanten Blöcken des Typs NVM_BLOCK_REDUNDANT gilt der Löschvorgang erst als erfolgreich, wenn beide redundanten NV-Blöcke gelöscht wurden ([SWS_NvM_00269]). Der Dateninhalt eines zugeordneten RAM-Blocks bleibt durch die Auftragsabwicklung stets unverändert ([SWS_NvM_00416]).

Ein Aufruf wird abgewiesen, wenn ein ROM-Block eines Datensatz-Blocks adressiert wird ([SWS_NvM_00661]) oder der Block mittels NvM_SetBlockLockStatus gesperrt ist ([SWS_NvM_00751]). Bei aktivierter Entwicklungserkennung (DET) meldet die Funktion NVM_E_UNINIT bei uninitialisiertem Modul ([SWS_NvM_00631]), NVM_E_PARAM_BLOCK_ID bei ungültiger BlockId ([SWS_NvM_00635]) sowie NVM_E_BLOCK_LOCKED bei blockiertem Block ([SWS_NvM_00757]). Besitzt der Block keine Sofort-Priorität („immediate priority“) bzw. ist Standard-Priorität konfiguriert, wird bei aktivem DET der Fehler NVM_E_BLOCK_CONFIG gemeldet und E_NOT_OK zurückgegeben ([SWS_NvM_00357], [SWS_NvM_00636]). Schlägt die spätere asynchrone Ausführung fehl, wird der Anforderungsstatus auf NVM_REQ_NOT_OK gesetzt ([SWS_NvM_00271]) und NVM_E_REQ_FAILED an das DEM gemeldet ([SWS_NvM_00663]).

Die Funktion NvM_InvalidateNvBlock ist ein asynchroner und reentranter Dienst der API-Konfigurationsklasse 3 zur Invalidierung eines NV-Blocks [SWS_NvM_00459], [SWS_NvM_00560]. Als Aufrufbedingung gilt, dass das NvM-Modul vorab durch die Modulumgebung initialisiert worden sein muss [SWS_NvM_00717]. Der Aufruf übernimmt den Parameter BlockId, reiht die Anforderung bei deaktiviertem Schreibschutz in die Warteschlange ein und kehrt mit E_OK zurück [SWS_NvM_00239], [SWS_NvM_00424]. Kann der Auftrag nicht akzeptiert werden, liefert die Funktion E_NOT_OK [SWS_NvM_00459].

Ein Aufruf wird synchron mit E_NOT_OK zurückgewiesen, wenn über BlockId ein ROM-Block eines Datensatz-Blocks (Dataset) angegeben wurde [SWS_NvM_00664]. Wurde der Block zuvor via NvM_SetBlockLockStatus gesperrt, weist die NvM den Auftrag ab [SWS_NvM_00751] und meldet bei aktiver Entwicklungsschnittstelle den DET-Fehler NVM_E_BLOCK_LOCKED [SWS_NvM_00756]. Ist der Block bereits eingereiht oder in Ausführung, erfolgt die DET-Meldung NVM_E_BLOCK_PENDING [SWS_NvM_00639].

Der eigentliche asynchrone Job invalidiert den referenzierten NV-Block [SWS_NvM_00421] unter Berücksichtigung folgender Randbedingungen:

• Bei redundanten Blöcken (NVM_BLOCK_REDUNDANT) wird das Auftragsergebnis erst dann auf NVM_REQ_OK gesetzt, wenn beide redundanten NV-Blöcke erfolgreich invalidiert sind [SWS_NvM_00274]; der gleiche Mechanismus findet auch bei NvM_FirstInitAll Anwendung [SWS_NvM_00919], [SWS_NvM_00920].
• Für Blöcke mit NVM_WRITE_BLOCK_ONCE belässt der Job den Schreibschutz unverändert [SWS_NvM_00960]. Ging kein Lesevorgang voraus, meldet der Job den DET-Fehler NVM_E_WRITE_ONCE_STATUS_UNKNOWN [SWS_NvM_00958].
• Tritt während der asynchronen Bearbeitung ein Fehler auf, wird das Anfrageergebnis auf NVM_REQ_NOT_OK gesetzt [SWS_NvM_00275] und der Produktionsfehler NVM_E_REQ_FAILED an das DEM übermittelt [SWS_NvM_00666].

Verwendung

Die asynchrone und reentrante Funktion [SWS_NvM_00764] dient dem Kopieren von Daten eines NV-Blocks in den zugeordneten permanenten RAM-Block. Der Aufruf übernimmt die BlockId, reiht die Leseanforderung in die interne Auftragswarteschlange ein und kehrt umgehend zurück [SWS_NvM_00766]. Der Rückgabewert E_OK bestätigt die Annahme des Auftrags, während E_NOT_OK eine Ablehnung signalisiert [SWS_NvM_00764]. Die Funktion gehört zum Funktionsumfang der API-Konfigurationsklassen 2 und 3 [SWS_NvM_00560], [SWS_NvM_00561].

Ablauf und Synchronisation

Mit erfolgreicher Einreihung des Auftrags oder Beginn der Verarbeitung wird der permanente RAM-Block unverzüglich invalidiert [SWS_NvM_00767]. Ist für den Block eine explizite Synchronisation eingerichtet, darf die Anwendung den RAM-Block bis zum Eintreffen der Synchronisationsroutine verändern; die Invalidierung erfolgt in diesem Fall direkt vor dem Aufruf von NvMReadRamBlockFromNvCallback [SWS_NvM_00706], [SWS_NvM_00767]. Wurden die NV-Daten fehlerfrei in das RAM übertragen, schließt der Auftrag mit dem Status NVM_REQ_OK ab [SWS_NvM_00765], [SWS_NvM_00775].

Fehlerbehandlung und Redundanz

Bei Blöcken vom Typ NVM_BLOCK_REDUNDANT startet der Auftrag automatisch einen Leseversuch auf dem zweiten Block, sofern der erste Leseversuch fehlschlägt [SWS_NvM_00768]. Bei Datasets (NVM_BLOCK_DATASET) wird das Kopieren unterbunden, falls der über den Index gewählte NV-Block inkonsistent ist [SWS_NvM_00771]; verweist der Index auf ROM-Daten, werden diese geladen und das Ergebnis auf NVM_REQ_OK gesetzt [SWS_NvM_00772]. Sind Standarddaten konfiguriert und der NV-Block bei ungültigem RAM-Zustand nicht lesbar, erfolgt eine implizite Wiederherstellung [SWS_NvM_00575], die den RAM-Block als gültig sowie geändert einstuft [SWS_NvM_00774]; ohne konfigurierte Vorgabewerte unterbleibt die Wiederherstellung [SWS_NvM_00572]. War zuvor NvM_SetBlockLockStatus aktiv, wird das Nachladen aus dem NV-Speicher erzwungen [SWS_NvM_00752].

Die reentrante, asynchrone Funktion NvM_WritePRAMBlock stößt das Schreiben der Daten eines permanenten RAM-Blocks in den zugehörigen NV-Block an [SWS_NvM_00793], [SWS_NvM_00794]. Die Funktion ist in den API-Konfigurationsklassen 2 und 3 verfügbar [SWS_NvM_00561], [SWS_NvM_00560]. Die reservierte Block-ID 1 darf nur übergeben werden, wenn NvMDynamicConfiguration auf TRUE gesetzt ist [SWS_NvM_00311].

Bei der Übergabe liefert die Funktion E_OK bei erfolgreicher Annahme oder E_NOT_OK [SWS_NvM_00793]. Ist der referenzierte Block gesperrt, schlägt der Aufruf mit E_NOT_OK fehl und das Modul meldet einen DET-Fehler [SWS_NvM_00797]. Ein Blockschutz wird bereits beim Einreihen in die Auftragsschlange geprüft und vor der Auftragsausführung nicht erneut validiert [SWS_NvM_00799]. Besitzt der NVRAM-Block Sofortpriorität (immediate priority), wird ein laufender Auftrag unmittelbar destruktiv abgebrochen und dieser Schreibauftrag als nächster verarbeitet [SWS_NvM_00800].

Vor der eigentlichen Übertragung in den NV-Speicher fordert der Auftrag eine CRC-Neuberechnung an, sofern der Block mit CRC konfiguriert ist [SWS_NvM_00801]. Ein noch ungültiger permanenter RAM-Block wird automatisch validiert [SWS_NvM_00803]. Bei redundanten Blöcken (NVM_BLOCK_REDUNDANT) werden beide NV-Blöcke beschrieben, beginnend mit demjenigen, der bei vorangegangenen Leseaufträgen nicht gelesen wurde [SWS_NvM_00807], [SWS_NvM_00808]. Bei Schreibfehlern wird die Anzahl der Wiederholungen durch NVM_MAX_NUM_OF_WRITE_RETRIES begrenzt [SWS_NvM_00806]; bei einem Überlauf setzt der NvM das Auftragsergebnis auf NVM_REQ_NOT_OK [SWS_NvM_00804] und meldet NVM_E_REQ_FAILED an das DEM [SWS_NvM_00805].

Hinsichtlich Nebenläufigkeit gilt: Bei impliziter Synchronisation darf die Applikation die Pufferdaten nach Aufruf bis zum Auftragsende nicht mehr modifizieren, lesender Zugriff bleibt gestattet [SWS_NvM_00698]. Bei expliziter Synchronisation darf der Puffer verändert werden, bis die Callback-Routine NvMWriteRamBlockToNvCallback aufgerufen wird [SWS_NvM_00705].

Verwendung und Semantik

Die Funktion NvM_RestorePRAMBlockDefaults stellt Standarddaten im zugehörigen permanenten RAM-Block wieder her ([SWS_NvM_00813], [SWS_NvM_00814]). Der Dienst arbeitet asynchron und übernimmt über den Parameter BlockId die Kennung des NVRAM-Block-Deskriptors ([SWS_NvM_00813]). Beim Aufruf wird die Anforderung in die interne Auftragswarteschlange eingereiht ([SWS_NvM_00815]). Der Rückgabewert E_OK signalisiert die erfolgreiche Annahme, während E_NOT_OK eine Abweisung anzeigt ([SWS_NvM_00813]). Ist ein ROM-Block konfiguriert, werden die Daten im Rahmen der asynchronen Verarbeitung aus diesem geladen ([SWS_NvM_00816]).

Fehlerbehandlung und Randbedingungen

Sind weder ROM-Standarddaten noch eine Callback-Routine NvMInitBlockCallback für den Block hinterlegt, bleibt der Blockstatus unverändert und der Aufruf liefert E_NOT_OK ([SWS_NvM_00884]). Bei aktivierter Entwicklungserkennung (DET) werden spezifische Fehler gemeldet:

• NVM_E_UNINIT: Das Modul ist noch nicht initialisiert ([SWS_NvM_00831]).
• NVM_E_PARAM_BLOCK_ID: Die übergebene BlockId liegt außerhalb des gültigen Bereichs ([SWS_NvM_00834]).
• NVM_E_BLOCK_PENDING: Für die Block-ID ist bereits ein Auftrag eingereiht oder in Bearbeitung ([SWS_NvM_00832]).
• NVM_E_BLOCK_WITHOUT_DEFAULTS: Es existieren weder ROM-Defaultdaten noch ein Initialisierungs-Callback ([SWS_NvM_00886]).
• NVM_E_PARAM_ADDRESS: Es ist weder ein permanenter RAM-Block noch eine explizite Synchronisation konfiguriert ([SWS_NvM_00894]).

Nebenläufigkeit und Zusammenspiel

Der Dienst ist als nicht reentrant spezifiziert ([SWS_NvM_00813]) und steht in den API-Konfigurationsklassen 2 und 3 zur Verfügung ([SWS_NvM_00561], [SWS_NvM_00560]). Dieselbe Wiederherstellungslogik kommt zudem intern bei NvM_ReadPRAMBlock zum Einsatz, falls der unterlagerte Lesevorgang fehlschlägt ([SWS_NvM_00789], [SWS_NvM_00882]).

Die Funktion NvM_ReadAll stößt asynchron einen Multi-Block-Leseauftrag zur Initialisierung der RAM-Datenblöcke an [SWS_NvM_00460], [SWS_NvM_00158]. Sie besitzt keine Parameter, liefert keinen Rückgabewert und ist nicht reentrant [SWS_NvM_00460]. Der Aufruf signalisiert die Anforderung an das NvM-Modul und kehrt sofort zurück; die eigentliche Abarbeitung wird jedoch verzögert, bis sämtliche Einzelblock-Auftragswarteschlangen leer sind [SWS_NvM_00243].

Zu Beginn validiert der Auftrag während des Systemstarts die Konfigurations-ID durch Vergleich des gespeicherten mit dem kompilierten Wert [SWS_NvM_00073], [SWS_NvM_00246]:

• Bei Übereinstimmung erfolgt die normale Vorbereitung für alle konfigurierten Blöcke [SWS_NvM_00247].
• Ein Konfigurationsunterschied wird ignoriert, wenn NvMDynamicConfiguration == FALSE gesetzt ist [SWS_NvM_00248].
• Ist NvMDynamicConfiguration == TRUE und NvMResistantToChangedSw == FALSE, wird bei Nichtübereinstimmung eine erweiterte Vorbereitung ausgeführt [SWS_NvM_00249].

Anschließend iteriert der Auftrag über alle Anwenderblöcke, beginnend mit der niedrigsten Block-ID (ausgenommen die reservierten IDs 0 und 1) [SWS_NvM_00244]. Berücksichtigt werden permanente RAM-Blöcke oder Blöcke mit konfiguriertem Synchronisations-Callback NvM_ReadRamBlockFromNvm, sofern NvmSelectBlockForReadall == TRUE konfiguriert ist [SWS_NvM_00118]. Nicht gelesene, aber selektierte Blöcke erhalten das Ergebnis NVM_REQ_BLOCK_SKIPPED [SWS_NvM_00287].

Bei redundanten Blöcken (NVM_BLOCK_REDUNDANT) wird bei Fehlschlag des ersten Leseversuchs automatisch der zweite NV-Block gelesen [SWS_NvM_00288]. Nach erfolgreichem Laden ins RAM wird der Blockstatus auf „valid/unmodified“ und das Auftragsergebnis auf NVM_REQ_OK gesetzt [SWS_NvM_00251], [SWS_NvM_00290], [SWS_NvM_00291]. Für Blöcke mit NvMCalRamBlockCrC == TRUE fordert der Auftrag eine CRC-Neuberechnung an [SWS_NvM_00292]. Sofern konfiguriert, wird je Block NvMSingleBlockCallback und nach dem letzten Block MultiBlockCallback aufgerufen [SWS_NvM_00281].

Verwendung und Aufrufkontext

Die Funktion NvM_WriteAll stößt asynchron einen Multi-Block-Schreibauftrag an und besitzt weder Parameter noch Rückgabewerte [SWS_NvM_00461]. Nach dem Aufruf signalisiert die Funktion die Anforderung an das NvM-Modul und kehrt unmittelbar zurück [SWS_NvM_00254]. Die eigentliche Verarbeitung wird zurückgestellt, bis alle Warteschlangen für Einzelblock-Aufträge vollständig abgearbeitet sind [SWS_NvM_00254]. Der Aufruf erfolgt typischerweise im Rahmen des grundlegenden Abschaltvorgangs (Shutdown) durch den BSW Mode Manager [SWS_NvM_00092].

Ablauf und Blockverarbeitung

Während des Shutdowns synchronisiert der Auftrag permanente RAM-Blöcke mit den zugehörigen NV-Blöcken oder führt den expliziten Synchronisations-Callback NvM_WriteRamBlockToNvm aus [SWS_NvM_00018]. Dabei werden ausschließlich Blöcke berücksichtigt, für die der Konfigurationsparameter NvMSelectBlockForWriteAll auf true gesetzt ist [SWS_NvM_00252], sowie Block 1 im Falle abweichender Konfigurations-IDs bei aktiver dynamischer Konfiguration [SWS_NvM_00310]. Falls für einen NVRAM-Block eine CRC konfiguriert ist, fordert der Auftrag vor dem Schreibvorgang eine Neuberechnung an und aktualisiert die Prüfsumme [SWS_NvM_00253]. Für Blöcke mit NvMWriteBlockOnce == TRUE setzt der Auftrag nach erfolgreichem Schreiben unmittelbar das Schreibschutz-Flag im administrativen Block [SWS_NvM_00329].

Nebenläufigkeit und Fehlerbehandlung

• Reentranz: Die Funktion ist nicht reentrant [SWS_NvM_00461].
• Fehlerüberwachung: Um Endlosschleifen zu vermeiden, überwacht ein Retry-Zähler die Wiederholungsversuche bei nicht erfolgreichen Rückmeldungen des MemIf-Moduls [SWS_NvM_00296].
• Auftragsergebnisse: Scheitert die Verarbeitung mindestens eines Blocks, wird das Gesamtergebnis auf NVM_REQ_NOT_OK gesetzt [SWS_NvM_00318]. Für konfigurierte Blöcke, die nicht geschrieben wurden, wird das Einzelergebnis NVM_REQ_BLOCK_SKIPPED gesetzt [SWS_NvM_00298]. Bei redundanten Blöcken (NVM_BLOCK_REDUNDANT) gilt der Einzelauftrag als NVM_REQ_OK, sobald mindestens einer der NV-Blöcke erfolgreich geschrieben wurde [SWS_NvM_00337].
• Abbruch: Ein laufender Auftrag kann durch NvM_CancelWriteAll abgebrochen werden [SWS_NvM_00019]. Dies führt zum Gesamtergebnis NVM_REQ_CANCELED [SWS_NvM_00237], wobei der gerade bearbeitete Block zerstörungsfrei und datenkonsistent vollendet wird [SWS_NvM_00238].

Verwendung und Semantik

Die Funktion NvM_CancelWriteAll dient dazu, eine laufende Mehrblock-Schreiboperation (NvM_WriteAll) vorzeitig abzubrechen [SWS_NvM_00458], [SWS_NvM_00019]. Der Aufruf ist asynchron, nicht reentrant, nimmt keine Parameter entgegen und liefert keinen Rückgabewert [SWS_NvM_00458]. Die Funktion signalisiert den Abbruchwunsch direkt an das Modul und kehrt umgehend zurück [SWS_NvM_00232]. Die Anforderung wird nicht in die Auftragswarteschlange eingereiht; es kann stets nur eine Anforderung dieses Typs anstehen [SWS_NvM_00420]. Ist zum Aufrufzeitpunkt keine Operation aktiv, bleibt der Aufruf ohne Wirkung [SWS_NvM_00233].

Ablauf und Datenkonsistenz

Der Abbruch wird so durchgeführt, dass die Datenkonsistenz des zum Zeitpunkt des Abbruchs bearbeiteten NVRAM-Blocks nicht beeinträchtigt wird [SWS_NvM_00019]. Das Modul schließt diesen aktiven Block regulär ab und setzt dessen Statusattribut je nach Erfolg auf NVM_REQ_OK oder NVM_REQ_NOT_OK, während alle verbleibenden noch ausstehenden Blöcke auf NVM_REQ_CANCELED gesetzt werden [SWS_NvM_00236]. Das Gesamtergebnis ist implizit durch das Ergebnis der abgebrochenen Operation vorgegeben [SWS_NvM_00235], wird in einer separaten Variablen abgelegt [SWS_NvM_00393] und kann über NvM_GetErrorStatus unter Angabe der reservierten Block-ID 0 abgefragt werden [SWS_NvM_00394]. Zudem kann optional ein übergeordneter Callback (NvMMultiBlockCallback) benachrichtigt werden [SWS_NvM_00260]. Sofern über NvMDrvModeSwitch konfiguriert, schaltet der Auftrag die Speichergeräte nach dem Abbruch in den langsamen Betriebsmodus („slow-mode“) um [SWS_NvM_00681].

Einschränkungen und Fehlerbehandlung

Der Aufruf von NvM_CancelWriteAll ist funktional eingeschränkt und darf ausschließlich durch den BSW Mode Manager (BswM) erfolgen [SWS_NvM_00703]. Zudem gehört die Funktion zur API-Konfigurationsklasse 2 [SWS_NvM_00561]. Das Modul muss vor dem Aufruf initialisiert worden sein [SWS_NvM_00716]; bei aktivierter Entwicklungserkennung (DET) führt ein Aufruf im uninitialisierten Zustand zur Fehlermeldung NVM_E_UNINIT [SWS_NvM_00637].

Die Funktion NvM_ValidateAll stößt die asynchrone Validierung mehrerer NVRAM-Blöcke an ([SWS_NvM_00855]) und gehört zur API-Konfigurationsklasse 3 ([SWS_NvM_00560]). Sie ist nicht reentrant, erwartet keine Parameter und liefert keinen Rückgabewert ([SWS_NvM_00855]). Vor dem Aufruf muss das NvM-Modul initialisiert sein ([SWS_NvM_00859]).

Beim Aufruf signalisiert die Funktion die Anforderung an das Modul und kehrt umgehend zurück ([SWS_NvM_00858]). Die tatsächliche Abarbeitung wird jedoch verzögert, bis alle Einzelblock-Auftragswarteschlangen vollständig abgearbeitet sind ([SWS_NvM_00858]). Für Multi-Block-Aufträge steht in der Auftragswarteschlange insgesamt nur ein einziger Platz zur Verfügung ([SWS_NvM_00380]). Das Gesamtergebnis des asynchronen Auftrags wird in einer separaten Zustandsvariablen geführt ([SWS_NvM_00393]).

Im Rahmen der Auftragsabarbeitung werden vorab sowohl das Multi-Block-Ergebnis als auch die Ergebnisse der betroffenen Einzelblöcke auf NVM_REQ_PENDING gesetzt ([SWS_NvM_00861]). Die Verarbeitung berücksichtigt ausschließlich Blöcke, für die NvMBlockUseAutoValidation auf TRUE konfiguriert ist ([SWS_NvM_00856], [SWS_NvM_00860]):

• Es werden permanente RAM-Blöcke verarbeitet oder die explizite Synchronisation über den Callback NvM_WriteRamBlockToNvm ausgeführt ([SWS_NvM_00860]).
• Der RAM-Block-Status wird auf „VALID / CHANGED“ gesetzt ([SWS_NvM_00856]).
• Ist zusätzlich eine CRC-Berechnung im RAM konfiguriert, fordert der Auftrag die Neuberechnung im Hintergrund an, die über NvM_MainFunction verarbeitet wird ([SWS_NvM_00857]).
• Nach erfolgreicher Validierung des RAM-Blocks wechselt das blockspezifische Ergebnis auf NVM_REQ_OK ([SWS_NvM_00862]).

Die Funktion NvM_FirstInitAll stößt die asynchrone Erstinitialisierung mehrerer konfigurierter Blöcke an ([SWS_NvM_91001]). Der Dienst ist nicht reentrant, erwartet keine Parameter und liefert keinen Rückgabewert ([SWS_NvM_91001]). Bei der Abarbeitung wird nicht berücksichtigt, ob ein Block im nichtflüchtigen Speicher bereits existiert oder gültig bzw. korrumpiert ist ([SWS_NvM_91001]). Die Warteschlangenlänge für Multi-Block-Aufträge (unter anderem aus NvM_FirstInitAll) beträgt eins, sodass nur ein einziger Multi-Block-Auftrag gleichzeitig eingereiht werden kann ([SWS_NvM_00380]).

Die Verarbeitung unterscheidet sich nach dem Verwaltungstyp des Blocks:

• NATIVE: Liegen Standarddaten vor, wird der NV-Block damit beschrieben ([SWS_NvM_00913]). Besitzt der Block permanenten RAM oder explizite Synchronisation, wird der RAM wie bei NvM_RestoreBlockDefaults mit den Standarddaten (ROM oder Init-Callback) aktualisiert ([SWS_NvM_00915]); ohne permanenten RAM und ohne explizite Synchronisation dient der interne NvM-Puffer als RAM, wobei der RAM-Zustand unberührt bleibt ([SWS_NvM_00914]). Fehlen Standarddaten ([SWS_NvM_00919]) oder schlägt ein konfigurierter Init-Callback mit einem Rückgabewert ungleich E_OK fehl ([SWS_NvM_00921]), wird der Block invalidiert.
• REDUNDANT: Sind Standarddaten vorhanden, werden beide Blockinstanzen damit geschrieben ([SWS_NvM_00916]) und bei vorhandenem permanentem RAM bzw. expliziter Synchronisation der RAM aktualisiert ([SWS_NvM_00918]); andernfalls wird der interne Puffer genutzt ([SWS_NvM_00917]). Liefert ein Init-Callback nicht E_OK, werden beide Instanzen invalidiert ([SWS_NvM_00922]).
• DATASET: Alle für die Verarbeitung konfigurierten Blöcke bzw. NV-Blockinstanzen dieses Typs werden ausnahmslos invalidiert ([SWS_NvM_00923], [SWS_NvM_00924]).

Schlägt das Schreiben eines NATIVE-Blocks mit Standarddaten ([SWS_NvM_00925]), die Invalidierung eines NATIVE-Blocks ([SWS_NvM_00927]) oder das Schreiben beider Instanzen eines REDUNDANT-Blocks ([SWS_NvM_00926]) fehl, setzt der Auftrag das Gesamtergebnis auf NVM_REQ_NOT_OK.

Verwendung

Die synchrone Callback-Funktion NvM_JobEndNotification wird von der unterlagerten Speicherabstraktion aufgerufen, um dem NVRAM-Manager das fehlerfreie Ende eines Auftrags zu signalisieren [SWS_NvM_00462]. Die Funktion besitzt weder Parameter noch einen Rückgabewert und ist über die Header-Datei NvM_MemIf.h mit der Service-ID 0x11 verfügbar [SWS_NvM_00462]. Eine erfolgreiche Benachrichtigung der Speicherabstraktion umfasst fehlerfrei abgeschlossene Lese-, Schreib- oder Löschoperationen [SWS_NvM_00111].

Nebenläufigkeit und Einschränkungen

Die Schnittstelle ist als nicht reentrant spezifiziert [SWS_NvM_00462]. Abhängig von der aufrufenden Funktion innerhalb der Speicherabstraktion kann diese Routine im Interrupt-Kontext ausgeführt werden [SWS_NvM_00111]. Alle Module der Speicherabstraktion sollten so konfiguriert werden, dass sie einheitlich denselben Modus – Callback oder Polling – verwenden [SWS_NvM_00111].

Konfiguration und Zusammenspiel

Das NvM-Modul stellt die Callback-Funktion NvM_JobEndNotification nur bereit, wenn der Polling-Modus über den Konfigurationsparameter NvMPollingMode deaktiviert ist [SWS_NvM_00440]. Zudem wird die Funktion durch allgemeine NvM-Konfigurationsparameter beeinflusst [SWS_NvM_00440].

Die Callback-Funktion NvM_JobErrorNotification ([SWS_NvM_00463]) dient der unterlagerten Speicherabstraktionsschicht dazu, das fehlerhafte Ende eines asynchronen Auftrags an das NVRAM-Manager-Modul (NvM) zu signalisieren. Der Aufruf erfolgt synchron und ist als nicht reentrant spezifiziert ([SWS_NvM_00463]).

Verwendung und Signatur

• Schnittstelle: Die Funktionsdeklaration wird über die Header-Datei NvM_MemIf.h zur Verfügung gestellt ([SWS_NvM_00463]).
• Signatur: Gemäß void NvM_JobErrorNotification(void) besitzt die Funktion weder Eingabe- noch Ausgabe- oder Ein-/Ausgabeparameter und liefert keinen Rückgabewert ([SWS_NvM_00463]).
• Service-ID: Die Funktion ist über die hexadezimale Kennung 0x12 identifiziert ([SWS_NvM_00463]).

Konfigurationsabhängigkeit und Zusammenspiel

Das Modul NvM stellt die Callback-Funktion NvM_JobErrorNotification nur dann bereit, wenn der Polling-Modus über den Konfigurationsparameter NvMPollingMode deaktiviert ist ([SWS_NvM_00441]). Wird Polling verwendet, entfällt dieser Benachrichtigungsmechanismus. Darüber hinaus wird die Funktion durch die allgemeinen Konfigurationsparameter nach [SWS_NvM_00028] Wortlaut noch nicht übernommen beeinflusst ([SWS_NvM_00441]).

Fehlerbehandlung und Nebenläufigkeit

Die Funktion dient ausschließlich der Fehlermeldung von Aufträgen und definiert weder eigene Fehlercodes noch DET- oder DEM-Rückmeldungen ([SWS_NvM_00463]). Aufgrund der Klassifizierung als Non Reentrant obliegt es vermutlich dem Aufrufer in der Speicherabstraktion sicherzustellen, dass keine überlappenden oder unterbrechenden Aufrufe stattfinden ([SWS_NvM_00463]). Frage Q-5f72d9d605c25922 (offen)

Verwendung

Die Funktion NvM_MainFunction besitzt weder Übergabeparameter noch einen Rückgabewert (void NvM_MainFunction(void)) und ist über SchM_NvM.h deklariert ([SWS_NvM_00464]). Sie dient der Abarbeitung der NVRAM-Manager-Aufträge ([SWS_NvM_00464], [SWS_NvM_00256]). Nach dem Abschluss eines asynchronen Dienstes führt sie konfigurierte Callback-Routinen zur Benachrichtigung der oberen Schicht aus ([SWS_NvM_00347]). Zudem übernimmt sie im Hintergrund angeforderte CRC-Neuberechnungen für NVRAM-Blöcke ([SWS_NvM_00333]), etwa infolge von NvM_SetRamBlockStatus ([SWS_NvM_00121]) oder NvM_ValidateAll ([SWS_NvM_00857]).

Ablaufsteuerung und Priorisierung

Sofern konfiguriert, überwacht die Funktion die Immediate-Priority-Queue auf Anforderungen mit Sofortpriorität ([SWS_NvM_00259]). Wurde eine reguläre Anforderung durch einen Sofortauftrag destruktiv abgebrochen, startet NvM_MainFunction diese nach dessen Abschluss neu ([SWS_NvM_00258]). Bei aktivem Polling-Modus prüft sie den Status der an die untere Schicht übergebenen Aufträge ([SWS_NvM_00346]). Während der Verarbeitung von NvM_WriteAll fragt sie zyklisch den Zustand der Speichertreiberabstraktion über MemIf_GetStatus für MEMIF_BROADCAST_ID ab und hält Callbacks an die obere Schicht zurück, solange MEMIF_BUSY_INTERNAL gemeldet wird ([SWS_NvM_00350]).

Fehlerbehandlung und Wiederholungen

Schlagen anwendungsspezifische Callbacks fehl, steuert NvM_MainFunction die Wiederholungsversuche:

• Liefert NvMReadRamBlockFromNvCallback den Wert E_NOT_OK, wiederholt das Modul den Aufruf im nächsten Zyklus von NvM_MainFunction ([SWS_NvM_00839]).
• Gibt NvMWriteRamBlockToNvCallback E_NOT_OK zurück, erfolgt die Wiederholung ebenfalls im nächsten Aufruf von NvM_MainFunction ([SWS_NvM_00840]).
• Gibt der explizite Synchronisations-Callback bei NvM_SetRamBlockStatus E_NOT_OK zurück, führt das Modul die konfigurierten Wiederholungen mit jeweils einem Versuch pro Aufruf von NvM_MainFunction aus ([SWS_NvM_00908]).

Verwendung

Die Callback-Routine NvM_SingleBlockCallbackFunction benachrichtigt die überlagerte Schicht synchron über den Abschluss einer zuvor angestoßenen asynchronen Einzelblock-Anforderung [SWS_NvM_00467].

Die Funktion verarbeitet zwei Übergabeparameter [SWS_NvM_00467]:

• BlockRequest (Typ NvM_BlockRequestType): Übergibt die Art der zuvor ausgeführten Blockanforderung, wie beispielsweise Lese- oder Schreiboperationen [SWS_NvM_00467].
• JobResult (Typ NvM_RequestResultType): Meldet das Gesamtergebnis des abgearbeiteten Blockauftrags [SWS_NvM_00467].

Als Rückgabewert liefert die Funktion den Typ Std_ReturnType [SWS_NvM_00467]. Eine erfolgreiche Abarbeitung des Callbacks wird durch die Rückgabe von E_OK signalisiert; jeder andere Rückgabewert kennzeichnet eine nicht erfolgreiche Ausführung [SWS_NvM_00467].

Fehlerbehandlung und Nebenläufigkeit

Die Schnittstelle spezifiziert keine eigenen DET- oder DEM-Fehlermeldungen [SWS_NvM_00467]. Das Ergebnis des vorangegangenen Auftrags wird über den Parameter JobResult übermittelt, während Fehler innerhalb der Callback-Bearbeitung selbst über den Funktionsrückgabewert gemeldet werden [SWS_NvM_00467].

Bezüglich der Nebenläufigkeit ist die Routine als nicht reentrant (Non Reentrant) deklariert [SWS_NvM_00467]. Sie wird über den Header NvM_Externals.h bereitgestellt [SWS_NvM_00467]. Der Aufruf durch das NvM-Modul dürfte synchron im Taskkontext der zyklischen NvM-Auftragsabarbeitung erfolgen (Interpretation). Frage Q-f50640211851274f (offen)

Die Callback-Routine NvM_MultiBlockCallbackFunction benachrichtigt die übergeordnete Schicht darüber, dass ein zuvor initiierter asynchroner Multiblock-Auftrag abgeschlossen wurde [SWS_NvM_00468]. Die Deklaration der Funktion wird über die Header-Datei NvM_Externals.h zur Verfügung gestellt [SWS_NvM_00468].

Aufrufkontext und Parameter

Der Aufruf durch den NVRAM-Manager erfolgt synchron zur Abarbeitung im Verarbeitungsablauf [SWS_NvM_00468]. Beim Aufruf werden der Routine zwei Parameter übergeben:

• MultiBlockRequest (Typ NvM_MultiBlockRequestType): Bezeichnet die konkrete Anforderungsart des zuvor bearbeiteten Multiblock-Auftrags, wie beispielsweise Lese- oder Schreibzugriffe [SWS_NvM_00468].
• JobResult (Typ NvM_RequestResultType): Übermittelt das Endergebnis der Verarbeitung des vorausgegangenen Multiblock-Jobs an die übergeordnete Schicht [SWS_NvM_00468].

Rückgabewert und Fehlerbehandlung

Die Routine gibt einen Wert vom Typ Std_ReturnType an das aufrufende Modul zurück [SWS_NvM_00468]. Der Rückgabewert E_OK zeigt an, dass die Callback-Funktion erfolgreich abgearbeitet werden konnte; jeder andere Rückgabewert signalisiert hingegen eine fehlgeschlagene Verarbeitung [SWS_NvM_00468]. Spezifische Fehlercodes, DET- oder DEM-Meldungen sind im Spezifikationsumfang für diese Funktion nicht definiert. Interpretation: Die konkreten Konsequenzen eines Rückgabewerts ungleich E_OK dürften implementationsspezifisch sein, da der Standard keine nachgelagerte Fehlerbehandlung vorschreibt. Frage Q-462dea7f3074ae9c (offen)

Nebenläufigkeit und Einschränkungen

Die Funktion ist als nicht reentrant (Non Reentrant) spezifiziert [SWS_NvM_00468]. Innerhalb des aufrufenden Systems muss deshalb sichergestellt werden, dass keine nebenläufigen oder unterbrechenden Mehrfachaufrufe dieser Callback-Schnittstelle stattfinden.

Verwendung und Aufrufkontext

Die anwenderspezifische Callback-Routine NvM_InitBlockCallbackFunction wird vom NvM-Modul aufgerufen, wenn Standarddaten für einen NVRAM-Block im RAM wiederhergestellt werden müssen und kein entsprechender ROM-Block konfiguriert ist [SWS_NvM_00469]. Der Aufruf erfolgt synchron und die Schnittstelle ist über den Header NvM_Externals.h deklariert [SWS_NvM_00469].

Als Übergabeparameter erhält die Funktion InitBlockRequest vom Typ NvM_InitBlockRequestType [SWS_NvM_00469]. Dieser Wert informiert die Routine über den spezifischen Anforderungstyp des aktuell verarbeiteten Blocks, wie etwa das Lesen oder Wiederherstellen von Daten (read, restore) [SWS_NvM_00469].

Rückgabewerte und Fehlerbehandlung

Die Routine gibt einen Statuswert vom Typ Std_ReturnType zurück [SWS_NvM_00469]:

• E_OK: Signalisiert dem NvM-Modul, dass die Callback-Funktion die Daten im RAM erfolgreich initialisiert und verarbeitet hat [SWS_NvM_00469].
• Jeder andere Rückgabewert: Zeigt an, dass die Initialisierung nicht erfolgreich abgeschlossen werden konnte [SWS_NvM_00469].

Spezifische Fehlercodes für DET oder DEM sind für die Schnittstelle selbst nicht spezifiziert [SWS_NvM_00469].

Nebenläufigkeit und Ausführungseinschränkungen

Die Schnittstelle ist als synchron und nicht reentrant (Non Reentrant) festgelegt [SWS_NvM_00469]. Da der NVRAM Manager synchron auf die Rückkehr der Funktion wartet, dürfte eine blockierende Ausführung innerhalb der Routine die Weiterverarbeitung des NvM unmittelbar anhalten (Interpretation). Frage Q-c0e43c9871c4f2d0 (offen)

Die blockspezifische Callback-Funktion NvM_WriteRamBlockToNvm dient der expliziten Synchronisation, um Anwendungsdaten aus dem RAM-Block in den internen RAM-Spiegel des NvM-Moduls zu kopieren [SWS_NvM_00539]. Sie ist deklarativ über NvM_Externals.h verfügbar und wird vom NvM synchron aufgerufen [SWS_NvM_00539].

Verwendung und Parameter

Die Funktion übergibt als Ausgabeparameter den Zeiger NvMBuffer, welcher die Zieladresse des NvM-Spiegels darstellt, an die die Daten geschrieben werden müssen [SWS_NvM_00539]. Als Rückgabewert liefert die Callback-Routine E_OK bei erfolgreicher Verarbeitung oder jeden anderen Wert bei fehlerhaftem Verlauf [SWS_NvM_00539].

Nebenläufigkeit und Einschränkungen

Gemäß Spezifikation ist NvM_WriteRamBlockToNvm nicht reentrant (Non Reentrant) ausgelegt [SWS_NvM_00539].

Zusammenspiel im Modul

• Beim Herunterfahren synchronisiert der Job NvM_WriteAll permanente RAM-Blöcke oder ruft die Callback-Routine NvM_WriteRamBlockToNvm zur expliziten Synchronisation auf [SWS_NvM_00018], sofern der Parameter NvMSelectBlockForWriteAll für den NVRAM-Block auf true konfiguriert ist [SWS_NvM_00252].
• Die Schreibjobs NvM_WriteBlock [SWS_NvM_00303] und NvM_WritePRAMBlock [SWS_NvM_00803] validieren einen noch ungültigen permanenten RAM-Block automatisch nach dem Aufruf von NvM_WriteRamBlockToNvm.

Die Funktion NvM_ReadRamBlockFromNvm ist eine blockspezifische Callback-Routine, die über NvM_Externals.h deklariert wird [SWS_NvM_00540]. Ihr Zweck besteht darin, der Anwendung das Kopieren von Daten aus dem internen Spiegelpuffer des NvM-Moduls in den zugehörigen RAM-Block zu ermöglichen, um eine explizite Synchronisation durchzuführen [SWS_NvM_00540], [SWS_NvM_00118].

Verwendung und Semantik

• Aufrufkontext und Nebenläufigkeit: Der Aufruf erfolgt synchron und ist als nicht reentrant (Non Reentrant) spezifiziert [SWS_NvM_00540].
• Parameter: Als Übergabeparameter dient der Zeiger NvMBuffer (Typ const void*). Er übergibt die Pufferadresse, aus welcher die Daten gelesen und in den RAM-Block kopiert werden können [SWS_NvM_00540].
• Rückgabewert und Fehlerbehandlung: Die Callback-Funktion liefert einen Std_ReturnType zurück. Der Rückgabewert E_OK signalisiert die erfolgreiche Abarbeitung; jeder andere Rückgabewert zeigt eine nicht erfolgreiche Verarbeitung an [SWS_NvM_00540].

Zusammenspiel

Im Rahmen des Multiblock-Dienstes NvM_ReadAll wird NvM_ReadRamBlockFromNvm für diejenigen NVRAM-Blöcke zur expliziten Synchronisation aufgerufen, die entsprechend konfiguriert sind und für die NvmSelectBlockForReadall == TRUE gilt [SWS_NvM_00118], [SWS_NvM_00356]. Dies stellt die Alternative zum direkten Kopiervorgang in permanente RAM-Blöcke dar, während NvM_ReadAll die Verwaltungsdaten der Blöcke initialisiert [SWS_NvM_00356].

Der Enumerationstyp NvM_MultiBlockRequestType wird über die Header-Datei NvM.h bereitgestellt und dient der eindeutigen Kennzeichnung einer ausgeführten Multi-Block-Anforderung [SWS_NvM_91003]. Der Typ wird verwendet, wenn das Ergebnis oder der Status einer Multi-Block-Operation über eine Callback-Funktion signalisiert oder an das Modul BswM gemeldet wird [SWS_NvM_91003].

Wertebereich und Semantik

Die Enumeration definiert folgende Werte zur Differenzierung der Multi-Block-Aufträge [SWS_NvM_91003]:

• NVM_READ_ALL (0x00): Zeigt an, dass NvM_ReadAll ausgeführt wurde.
• NVM_WRITE_ALL (0x01): Zeigt an, dass NvM_WriteAll ausgeführt wurde.
• NVM_VALIDATE_ALL (0x02): Zeigt an, dass NvM_ValidateAll ausgeführt wurde.
• NVM_FIRST_INIT_ALL (0x03): Zeigt an, dass NvM_FirstInitAll ausgeführt wurde.
• NVM_CANCEL_WRITE_ALL (0x04): Zeigt an, dass NvM_CancelWriteAll ausgeführt wurde.

Zusammenspiel

Durch die Übergabe dieses Typs können aufgerufene Callbacks sowie der BswM feststellen, welcher konkrete Mehrblock-Dienst die Benachrichtigung ausgelöst hat. Interpretation: Vermutlich dient die Rückmeldung an den BswM dazu, Folgeaktionen oder Zustandswechsel im Gesamtsystem an den Abschluss spezifischer Multi-Block-Dienste zu koppeln. Frage Q-69b4d985301acfeb (offen)

Der Typ NvM_RequestResultType basiert auf uint8, steht über Rte_NvM_Type.h bereit und bildet das asynchrone Anfrageergebnis von Lese-, Schreib- und Steueraufträgen des NVRAM-Managers ab [SWS_NvM_00470]. Das Ergebnis wird primär über den API-Dienst NvM_GetErrorStatus abgefragt und kann zusätzlich über eine konfigurierte Callback-Funktion signalisiert werden [SWS_NvM_00470].

Der Wertebereich bildet verschiedene Ausführungszustände und Fehlerfälle ab [SWS_NvM_00470]:

• NVM_REQ_OK (0x00): Der letzte asynchrone Auftrag wurde erfolgreich beendet; dies ist zugleich der Standardwert nach einem Reset.
• NVM_REQ_NOT_OK (0x01): Die asynchrone Lese-, Schreib- oder Steueranforderung wurde nicht erfolgreich beendet.
• NVM_REQ_PENDING (0x02): Eine asynchrone Anforderung ist aktuell noch in Bearbeitung.
• NVM_REQ_INTEGRITY_FAILED (0x03): Datenintegritätsfehler bei NvM_ReadBlock oder NvM_ReadAll. Im Fall von NvM_ReadBlock wurde der Inhalt des RAM-Blocks verändert, ist jedoch ungültig geworden; die Applikation ist dafür verantwortlich, den Inhalt zu erneuern und zu validieren.
• NVM_REQ_BLOCK_SKIPPED (0x04): Der referenzierte Block wurde während NvM_ReadAll oder NvM_WriteAll übersprungen (z. B. Dataset-NVRAM-Blöcke bei NvM_ReadAll oder Blöcke ohne permanent konfigurierten RAM-Block).
• NVM_REQ_NV_INVALIDATED (0x05): Der referenzierte NV-Block ist invalidiert.
• NVM_REQ_CANCELED (0x06): Abbruch von NvM_WriteAll durch NvM_CancelWriteAll oder Abbruch eines Einzelblock-Auftrags (NvM_ReadBlock, NvM_WriteBlock, NvM_EraseNvBlock, NvM_InvalidateNvBlock, NvM_RestoreBlockDefaults) durch NvM_CancelJobs.
• NVM_REQ_RESTORED_DEFAULTS (0x08): Die Standardwerte wurden erfolgreich in das RAM-Abbild kopiert.

Im Zusammenspiel mit redundanten Blöcken (NVM_BLOCK_REDUNDANT) setzt die Funktion NvM_InvalidateNvBlock das Anfrageergebnis NvM_RequestResultType erst dann auf NVM_REQ_OK, wenn beide NV-Blöcke invalidiert wurden [SWS_NvM_00274].

Der Datentyp NvM_InitBlockRequestType basiert auf uint8 und wird über die Header-Datei Rte_NvM_Type.h bereitgestellt [SWS_NvM_91123]. Er dient dazu, die Art der an einem NVRAM-Block durchgeführten Anforderung zu identifizieren, wenn diese über eine entsprechende Callback-Funktion signalisiert wird [SWS_NvM_91123].

Der zulässige Wertebereich umfasst vier Anforderungstypen [SWS_NvM_91123]:

• NVM_INIT_READ_BLOCK (0x00): Zeigt an, dass NvM_ReadBlock oder NvM_ReadPRAMBlock für den Block angefordert wurde [SWS_NvM_91123].
• NVM_INIT_RESTORE_BLOCK_DEFAULTS (0x01): Signalisiert, dass NvM_RestoreBlockDefaults oder NvM_RestorePRAMBlockDefaults für den Block angefordert wurde [SWS_NvM_91123].
• NVM_INIT_READ_ALL_BLOCK (0x02): Weist darauf hin, dass die Verarbeitung des Blocks im Rahmen von NvM_ReadAll erfolgt [SWS_NvM_91123].
• NVM_INIT_FIRST_INIT_ALL (0x03): Kennzeichnet die Blockverarbeitung während des Ablaufs von NvM_FirstInitAll [SWS_NvM_91123].

Anhand dieses Aufzählungswerts kann die aufgerufene Anwendungslogik unterscheiden, ob es sich um eine explizite Einzelblockanforderung (Lesen oder Wiederherstellen von Standardwerten) oder um eine globale Sammeloperation während des Systemanlaufs handelt [SWS_NvM_91123]. Interpretation: Der Typ dürfte als Parameter an blockbezogene Initialisierungs-Callbacks übergeben werden, damit die Anwendung situationsgerecht Standarddaten bereitstellen oder spezifische Vorbereitungen treffen kann. Frage Q-42d0d469e305728e (offen)

Der Aufzählungstyp NvM_BlockRequestType basiert auf uint8 und wird über den Header Rte_NvM_Type.h zur Verfügung gestellt [SWS_NvM_91002]. Er dient dazu, bei einer Benachrichtigung über eine Callback-Funktion die Art der Anforderung zu übermitteln, die zuvor auf einem NVRAM-Block ausgeführt wurde [SWS_NvM_91002].

Der Wertebereich umfasst sechs spezifische Blockanforderungen [SWS_NvM_91002]:

• NVM_READ_BLOCK (0x00): Signalisiert, dass NvM_ReadBlock oder NvM_ReadPRAMBlock für den Block ausgeführt wurde [SWS_NvM_91002].
• NVM_WRITE_BLOCK (0x01): Signalisiert, dass NvM_WriteBlock oder NvM_WritePRAMBlock für den Block ausgeführt wurde [SWS_NvM_91002].
• NVM_RESTORE_BLOCK_DEFAULTS (0x02): Signalisiert, dass NvM_RestoreBlockDefaults oder NvM_RestorePRAMBlockDefaults ausgeführt wurde [SWS_NvM_91002].
• NVM_ERASE_NV_BLOCK (0x03): Signalisiert, dass NvM_EraseNvBlock auf dem Block ausgeführt wurde [SWS_NvM_91002].
• NVM_INVALIDATE_NV_BLOCK (0x04): Signalisiert, dass NvM_InvalidateNvBlock auf dem Block ausgeführt wurde [SWS_NvM_91002].
• NVM_READ_ALL_BLOCK (0x05): Signalisiert, dass NvM_ReadAll die Bearbeitung dieses Blocks abgeschlossen hat [SWS_NvM_91002].

In der Anwendungsarchitektur dürfte der Wert als Parameter in Callback-Routinen ausgewertet werden, um übergeordnete Softwarekomponenten über das Ende bestimmter Blockoperationen differenziert zu informieren [SWS_NvM_91002]. Frage Q-467801b6b5e898a2 (offen) Mangels weiterer Vorgaben im Payload zu Fehlercodes oder Nebenläufigkeit beschränken sich die Spezifikationsdetails auf die Typdefinition und den Wertebereich [SWS_NvM_91002].