NVRAM Manager (NvM)

Utilisation et contexte d'appel

La fonction NvM_Init sert à réinitialiser de manière synchrone toutes les variables internes du gestionnaire de NVRAM [SWS_NvM_00447]. Elle attend comme paramètre de transmission ConfigPtr un pointeur vers le jeu de données de configuration sélectionné et ne possède aucune valeur de retour [SWS_NvM_00447]. En tant qu’API de type 4, elle fait partie des classes de configuration 2 et 3 [SWS_NvM_00560], [SWS_NvM_00561]. La fonction est non réentrante et ne doit être appelée que par le BSW Mode Manager [SWS_NvM_00447], [SWS_NvM_00693].

Tâches d’initialisation

Pendant l’appel, la fonction effectue les actions suivantes :

• réinitialisation de toutes les variables internes, notamment les machines d’état, les files d’attente de requêtes et les indicateurs de demande, à leurs valeurs initiales [SWS_NvM_00399].
• mise à zéro de l’index de jeu de données de tous les blocs NVRAM de type NVM_BLOCK_DATASET [SWS_NvM_00192].
• positionnement interne du signal « INIT DONE », qui constitue le prérequis pour le traitement des requêtes, la gestion des files d’attente et le recalcul du CRC dans le module [SWS_NvM_00257], [SWS_NvM_00399].

Restrictions et interaction

En raison d’exigences strictes concernant le temps de démarrage du calculateur (ECU), NvM_Init n’initialise aucun bloc NVRAM configuré [SWS_NvM_00091]. Les contenus permanents des blocs RAM ne sont pas modifiés et les rappels de synchronisation ne sont pas appelés ; ceci est réservé à la fonction NvM_ReadAll [SWS_NvM_00400]. De plus, NvM_Init n’initialise ni les pilotes sous-jacents, ni l’abstraction matérielle de mémoire, ni des modules tiers, étant donné que leur initialisation par le BSW Mode Manager est présupposée [SWS_NvM_00157], [SWS_NvM_00193].

Utilisation et sémantique

La fonction synchrone et réentrante NvM_SetBlockProtection sert à activer ou à désactiver la protection en écriture pour un bloc NVRAM via l’attribut correspondant dans le bloc administratif [SWS_NvM_00450], [SWS_NvM_00016]. Elle est affectée à la classe de configuration d’API 3 [SWS_NvM_00560]. L’environnement du module NvM peut activer ou désactiver de manière ciblée la protection en écriture via le paramètre ProtectionEnabled [SWS_NvM_00578]. La fonction renvoie E_OK en cas d’exécution réussie et E_NOT_OK en cas d’erreur [SWS_NvM_00450].

Restrictions et concurrence

La modification de la protection en écriture n’est autorisée que pour les blocs pour lesquels NvMWriteBlockOnce est configuré sur FALSE, indépendamment de la valeur du paramètre NvMBlockWriteProt [SWS_NvM_00325]. Si NvMWriteBlockOnce est configuré sur TRUE, la protection en écriture ne doit être ni activée ni désactivée [SWS_NvM_00398], [SWS_NvM_00577] ; cette protection ne peut pas non plus être levée après des opérations de lecture [SWS_NvM_00314], [SWS_NvM_00316], [SWS_NvM_00784]. De plus, un état de verrouillage défini via NvM_SetBlockLockStatus ne peut pas être modifié par NvM_SetBlockProtection [SWS_NvM_00754]. Tant qu’une requête de bloc individuel pour le même bloc est active ou mise en file d’attente, l’appel n’est pas autorisé [SWS_NvM_00704].

Gestion des erreurs

Lorsque la détection des erreurs de développement (DET) est activée, la fonction signale des états d’erreur spécifiques :

• NVM_E_UNINIT, si le module NvM n’est pas encore initialisé [SWS_NvM_00606].
• NVM_E_PARAM_BLOCK_ID, lorsque l'BlockId transmise se situe en dehors de la plage valide [SWS_NvM_00609].
• NVM_E_BLOCK_PENDING, si une opération est déjà active ou mise en file d’attente pour le bloc [SWS_NvM_00607].
• NVM_E_BLOCK_CONFIG, si le bloc est configuré avec NvMWriteBlockOnce = TRUE [SWS_NvM_00608].
• NVM_E_BLOCK_LOCKED, si le bloc est verrouillé [SWS_NvM_00759].

Utilisation et contexte d'appel

La fonction synchrone et réentrante NvM_SetBlockLockStatus sert au verrouillage (BlockLocked = TRUE) ou au déverrouillage (BlockLocked = FALSE) d'un bloc RAM configuré comme permanent ou à la synchronisation explicite d'un bloc NVRAM [SWS_NvM_00548]. Elle fait partie du périmètre fonctionnel des classes de configuration d'API 2 et 3 [SWS_NvM_00561], [SWS_NvM_00560]. La fonction n'est pas incluse dans l'interface ServicePort et est principalement appelée par le DCM ainsi que par des pilotes de périphériques complexes (CDD) [SWS_NvM_00732].

Restrictions et interaction

L'appel agit exclusivement sur les blocs NVRAM disposant d'un bloc RAM permanent ou d'une synchronisation explicite configurée ; il reste sans effet pour tous les autres blocs [SWS_NvM_00732]. Si un bloc est verrouillé (BlockLocked = TRUE), le NvM s'assure que les données NV associées ne sont pas modifiées : le bloc est ignoré lors de NvM_WriteAll, et les services NvM_WriteBlock, NvM_WritePRAMBlock, NvM_InvalidateNvBlock ainsi que NvM_EraseNvBlock sont rejetés [SWS_NvM_00751]. Lors du démarrage suivant, le NvM charge à coup sûr le bloc depuis la mémoire NV lors de NvM_ReadBlock ou NvM_ReadPRAMBlock [SWS_NvM_00752]. L'état de verrouillage défini ne peut être modifié ni via NvM_SetRamBlockStatus ni via NvM_SetBlockProtection [SWS_NvM_00754]. La transmission de BlockLocked = FALSE rétablit le traitement régulier [SWS_NvM_00753].

Gestion des erreurs

Lorsque la détection des erreurs de développement (DET) est activée, la fonction signale des erreurs de développement spécifiques :

• NVM_E_UNINIT, si le module NvM n'est pas encore initialisé au moment de l'appel [SWS_NvM_00728].
• NVM_E_PARAM_BLOCK_ID, lorsque le paramètre BlockId se situe en dehors de la plage admissible [SWS_NvM_00731].
• NVM_E_BLOCK_CONFIG, pour autant que le bloc NVRAM référencé soit configuré avec le paramètre NvMWriteBlockOnce = TRUE [SWS_NvM_00730].

Utilisation et sémantique

La fonction NvM_CancelJobs disponible via NvM.h sert à annuler de manière synchrone toutes les tâches en attente dans la file d'attente pour un bloc NVRAM déterminé [SWS_NvM_00535], [SWS_NvM_00536]. La fonction est conçue pour être réentrante et attend en paramètre le BlockId, qui identifie de manière unique le descripteur de bloc du bloc NVRAM concerné [SWS_NvM_00535]. L'appel renvoie E_OK si les tâches en attente ont pu être retirées avec succès de la file d'attente, et E_NOT_OK si aucune tâche n'a pu être trouvée dans la file d'attente pour le bloc spécifié [SWS_NvM_00535].

Déroulement et concurrence

Une tâche déjà activement en cours de traitement au moment de l'appel de la fonction n'est pas interrompue par NvM_CancelJobs, mais continue jusqu'à la fin [SWS_NvM_00537]. Si la demande d'annulation est acceptée pour les tâches en attente, le service définit préalablement le résultat de requête spécifique au bloc à NVM_REQ_CANCELED [SWS_NvM_00225], [SWS_NvM_00536]. Le but de ce nettoyage est de vider la file d'attente, par exemple lors de la terminaison ou du redémarrage d'une partition, et d'empêcher ainsi les notifications ultérieures sur les jobs terminés [SWS_NvM_00225].

Gestion des erreurs et configuration

Lorsque la détection des erreurs de développement (DET) est activée, la fonction vérifie les préconditions : si le module n'est pas encore initialisé, l'erreur NVM_E_UNINIT est signalée [SWS_NvM_00648]. Si le BlockId transmis se situe en dehors de la plage valide, la notification DET NVM_E_PARAM_BLOCK_ID a lieu [SWS_NvM_00649]. NvM_CancelJobs est classée comme API de type 2 et est disponible dans les classes de configuration d'API 2 et 3 [SWS_NvM_00561], [SWS_NvM_00560].

Utilisation et sémantique

La fonction NvM_ReadBlock sert à la copie asynchrone de données utiles depuis la mémoire NV vers le bloc RAM associé [SWS_NvM_00010], [SWS_NvM_00454]. L'appel est réentrant [SWS_NvM_00454]. Il prend en charge les paramètres, place la demande de lecture dans la file d'attente interne des tâches et renvoie immédiatement E_OK en cas d'acceptation réussie ou E_NOT_OK en cas de rejet [SWS_NvM_00195], [SWS_NvM_00454].

Si un pointeur NvM_DstPtr est transmis, les données peuvent être lues dans un tampon RAM temporaire par dérogation à la configuration du bloc ; un pointeur NULL non autorisé entraîne dans ce scénario une erreur DET [SWS_NvM_00196], [SWS_NvM_00278]. Un bloc RAM permanent configuré est directement marqué comme invalide lors de la mise en file d'attente ou au début du traitement de la tâche [SWS_NvM_00198]. Ce n'est qu'après une opération de copie réussie que le bloc RAM est considéré comme valide et inchangé [SWS_NvM_00200], et le résultat de la tâche passe à NVM_REQ_OK [SWS_NvM_00206].

Gestion des erreurs et intégrité des données

Si une somme de contrôle est activée pour le bloc (NvMCalRamBlockCrC == TRUE), la tâche demande un recalcul après la copie [SWS_NvM_00201] :

• En cas d'erreurs CRC, NVM_E_INTEGRITY_FAILED est signalé au DEM [SWS_NvM_00203]. Si elles existent, les valeurs par défaut sont chargées et le résultat est défini sur NVM_REQ_RESTORED_DEFAULTS [SWS_NvM_00202]. En l'absence de données ROM et de rappels d'initialisation, il en résulte NVM_REQ_INTEGRITY_FAILED [SWS_NvM_00204].
• Si le pilote de mémoire signale MEMIF_JOB_FAILED et qu'aucune valeur de remplacement n'est disponible, la tâche se termine par NVM_REQ_NOT_OK [SWS_NvM_00359].

Particularités des types de blocs

• Redundant : si la lecture de la première copie échoue, la deuxième copie NV est automatiquement utilisée [SWS_NvM_00199]. Si les deux copies sont invalides, le bloc global est invalidé [SWS_NvM_00317].
• Dataset : si le bloc sélectionné via l'index d'ensemble de données est marqué comme invalide, la copie dans la RAM n'a pas lieu [SWS_NvM_00355].
• Write-Once : les blocs lus de manière cohérente avec NVM_WRITE_BLOCK_ONCE positionné sont protégés de manière permanente en écriture [SWS_NvM_00316].

La fonction NvM_WriteBlock sert à copier les données d'un bloc de RAM dans le bloc NV associé [SWS_NvM_00455], [SWS_NvM_00410]. L'appel est exécuté de manière réentrante et asynchrone : la fonction prend en charge les paramètres transmis BlockId ainsi que NvM_SrcPtr, met en file d'attente la requête d'écriture dans la file d'attente interne des travaux et retourne immédiatement [SWS_NvM_00208]. La valeur de retour signale par E_OK l'acceptation réussie ou par E_NOT_OK le rejet de la requête [SWS_NvM_00455].

Concernant le paramétrage et la source des données, les prescriptions suivantes s'appliquent :

• Si une adresse RAM valide est transmise via NvM_SrcPtr, la requête d'écriture utilise ce tampon [SWS_NvM_00210]. Cela permet également de sauvegarder des blocs de RAM temporaires dans le cas de blocs configurés comme permanents ou avec synchronisation explicite [SWS_NvM_00280].
• Un bloc de RAM permanent configuré est supposé valide ou est automatiquement validé avant l'opération de copie [SWS_NvM_00303].
• Si une somme de contrôle est configurée pour le bloc NV, le travail demande un recalcul du CRC avant l'opération d'écriture [SWS_NvM_00212].
• Pour les blocs de jeux de données (NVM_BLOCK_DATASET), la cible est sélectionnée via l'index de données enregistré dans le bloc administratif [SWS_NvM_00338].
• Pour les blocs redondants (NVM_BLOCK_REDUNDANT), le travail se termine par NVM_REQ_OK dès qu'au moins une copie a été écrite avec succès [SWS_NvM_00284].
• Si NvMWriteBlockOnce == TRUE est défini, le travail active immédiatement la protection en écriture dans le bloc administratif après une écriture réussie [SWS_NvM_00328].
• Les requêtes d'écriture pour l'ID de bloc réservé 1 ne sont autorisées que si NvMDynamicConfiguration est activé [SWS_NvM_00311].

Traitement des erreurs et concurrence :

• Si la détection de développement est active, NvM_WriteBlock signale l'erreur DET NVM_E_UNINIT si le module n'est pas initialisé [SWS_NvM_00619] ainsi que NVM_E_BLOCK_PENDING si le même bloc est déjà en cours de traitement ou en file d'attente [SWS_NvM_00620]. Un pointeur source manquant pour les tampons temporaires entraîne une erreur de paramètre DET [SWS_NvM_00280].
• Les retours négatifs de l'interface de mémoire incrémentent le compteur de nouvelles tentatives ; après dépassement de NVM_MAX_NUM_OF_WRITE_RETRIES, le travail se termine par NVM_REQ_NOT_OK [SWS_NvM_00213], [SWS_NvM_00216].
• Si le bloc est configuré avec une priorité immédiate, NvM_WriteBlock interrompt de manière destructive un travail en cours d'exécution afin que la requête d'écriture soit traitée en priorité [SWS_NvM_00300].

Utilisation et sémantique

La fonction NvM_RestoreBlockDefaults restaure les données par défaut dans le bloc RAM attribué ([SWS_NvM_00456], [SWS_NvM_00012]). Elle fonctionne de manière asynchrone : après l'appel, elle prend en charge les paramètres, place la demande dans la file d'attente interne des tâches et retourne immédiatement avec E_OK en cas d'acceptation réussie ou avec E_NOT_OK en cas de rejet ([SWS_NvM_00456], [SWS_NvM_00224]). Si une adresse RAM valide est transmise via le paramètre de sortie NvM_DestPtr, celle-ci est utilisée comme adresse de destination ([SWS_NvM_00435]). Pour copier des données ROM dans un bloc RAM temporaire alors qu'un bloc RAM permanent ou des rappels de synchronisation sont configurés, l'appelant doit impérativement transmettre un pointeur différent de NULL ([SWS_NvM_00436]).

Gestion des erreurs et conditions limites

La fonction est non réentrante ([SWS_NvM_00456]) et fait partie des classes de configuration d'API 2 et 3 ([SWS_NvM_00561], [SWS_NvM_00560]). Si la détection des erreurs de développement (DET) est active, elle signale NVM_E_UNINIT si le module n'est pas encore initialisé ([SWS_NvM_00625]), NVM_E_PARAM_BLOCK_ID en cas de BlockId invalide ([SWS_NvM_00630]), ainsi qu'une erreur de paramètre si aucun pointeur de destination valide n'est transmis pour la copie temporaire dans le cas de blocs configurés de manière permanente ([SWS_NvM_00436]). La fonction échoue de manière synchrone avec E_NOT_OK si le bloc est de type NVM_BLOCK_DATASET, qu'au moins un bloc ROM existe et que l'index de données actuel pointe vers un bloc NV ([SWS_NvM_00353]).

Traitement des tâches et interaction

Dans le cadre du traitement asynchrone des tâches, le service charge des valeurs par défaut à partir d'un bloc ROM configuré ([SWS_NvM_00267]). Si un bloc RAM permanent est demandé ou si un rappel de synchronisation explicite (NvMReadRamBlockFromNvCallback) est utilisé, le bloc RAM est invalidé avant l'opération de copie ou avant l'appel du rappel ([SWS_NvM_00227]). Après une opération de copie réussie ou après le retour du rappel de synchronisation avec E_OK, le bloc RAM est validé et marqué comme modifié ([SWS_NvM_00228]). Si une somme de contrôle est configurée pour le bloc, la tâche demande enfin un recalcul CRC ([SWS_NvM_00229]). NvM_ReadBlock et NvM_ReadAll utilisent également la même logique de restauration en tant que mécanisme de repli en cas d'accès erroné en lecture mémoire ou d'erreurs CRC ([SWS_NvM_00202], [SWS_NvM_00293], [SWS_NvM_00657]).

La fonction réentrante et asynchrone NvM_EraseNvBlock ([SWS_NvM_00457]) de la classe de configuration d'API 3 ([SWS_NvM_00560]) sert à effacer un bloc de mémoire non volatile sur la base du BlockId transmis. Tant qu'aucune protection en écriture n'est active, la fonction prend en charge les paramètres, place la tâche d'effacement dans la file d'attente interne des tâches et retourne immédiatement ([SWS_NvM_00231], [SWS_NvM_00418]). La valeur de retour E_OK signale l'acceptation réussie de la tâche, tandis que E_NOT_OK indique le rejet ([SWS_NvM_00457]).

Avant l'appel, le module NvM doit être entièrement initialisé ([SWS_NvM_00715]). Après la mise en file d'attente, la protection en écriture n'est pas revérifiée avant le retrait de la tâche de la file d'attente ([SWS_NvM_00662]). Pour les blocs redondants de type NVM_BLOCK_REDUNDANT, l'opération d'effacement n'est considérée comme réussie que lorsque les deux blocs NV redondants ont été effacés ([SWS_NvM_00269]). Le contenu des données d'un bloc RAM attribué reste systématiquement inchangé tout au long de l'exécution de la tâche ([SWS_NvM_00416]).

Un appel est rejeté si un bloc ROM d'un bloc d'ensemble de données est adressé ([SWS_NvM_00661]) ou si le bloc est verrouillé au moyen de NvM_SetBlockLockStatus ([SWS_NvM_00751]). Lorsque la détection des erreurs de développement (DET) est activée, la fonction signale NVM_E_UNINIT en cas de module non initialisé ([SWS_NvM_00631]), NVM_E_PARAM_BLOCK_ID en cas de BlockId invalide ([SWS_NvM_00635]) ainsi que NVM_E_BLOCK_LOCKED en cas de bloc verrouillé ([SWS_NvM_00757]). Si le bloc ne possède pas de priorité immédiate (« immediate priority ») ou si la priorité standard est configurée, l'erreur NVM_E_BLOCK_CONFIG est signalée lorsque le DET est actif et E_NOT_OK est renvoyé ([SWS_NvM_00357], [SWS_NvM_00636]). Si l'exécution asynchrone ultérieure échoue, l'état de la demande est défini sur NVM_REQ_NOT_OK ([SWS_NvM_00271]) et NVM_E_REQ_FAILED est signalé au DEM ([SWS_NvM_00663]).

La fonction NvM_InvalidateNvBlock est un service asynchrone et réentrant de la classe de configuration d'API 3 pour l'invalidation d'un bloc NV [SWS_NvM_00459], [SWS_NvM_00560]. La condition d'appel stipule que le module NvM doit avoir été préalablement initialisé par l'environnement du module [SWS_NvM_00717]. L'appel prend en charge le paramètre BlockId, place la requête dans la file d'attente lorsque la protection en écriture est désactivée et retourne avec E_OK [SWS_NvM_00239], [SWS_NvM_00424]. Si la tâche ne peut pas être acceptée, la fonction renvoie E_NOT_OK [SWS_NvM_00459].

Un appel est rejeté de manière synchrone avec E_NOT_OK si un bloc ROM d'un bloc d'ensemble de données (Dataset) a été spécifié via BlockId [SWS_NvM_00664]. Si le bloc a été préalablement verrouillé via NvM_SetBlockLockStatus, le NvM rejette la tâche [SWS_NvM_00751] et signale l'erreur DET NVM_E_BLOCK_LOCKED si l'interface de développement est active [SWS_NvM_00756]. Si le bloc est déjà en file d'attente ou en cours d'exécution, la notification DET NVM_E_BLOCK_PENDING est émise [SWS_NvM_00639].

Le job asynchrone proprement dit invalide le bloc NV référencé [SWS_NvM_00421] en tenant compte des conditions limites suivantes :

• Pour les blocs redondants (NVM_BLOCK_REDUNDANT), le résultat de la tâche n'est défini à NVM_REQ_OK que lorsque les deux blocs NV redondants sont invalidés avec succès [SWS_NvM_00274] ; le même mécanisme s'applique également à NvM_FirstInitAll [SWS_NvM_00919], [SWS_NvM_00920].
• Pour les blocs avec NVM_WRITE_BLOCK_ONCE, le job laisse la protection en écriture inchangée [SWS_NvM_00960]. Si aucune opération de lecture n'a précédé, le job signale l'erreur DET NVM_E_WRITE_ONCE_STATUS_UNKNOWN [SWS_NvM_00958].
• Si une erreur survient pendant le traitement asynchrone, le résultat de la requête est défini à NVM_REQ_NOT_OK [SWS_NvM_00275] et l'erreur de production NVM_E_REQ_FAILED est transmise au DEM [SWS_NvM_00666].

Utilisation

La fonction asynchrone et réentrante [SWS_NvM_00764] sert à copier des données d'un bloc NV dans le bloc RAM permanent associé. L'appel prend en charge le BlockId, place la requête de lecture dans la file d'attente de tâches interne et retourne immédiatement [SWS_NvM_00766]. La valeur de retour E_OK confirme l'acceptation de la tâche, tandis que E_NOT_OK signale un rejet [SWS_NvM_00764]. La fonction fait partie du périmètre fonctionnel des classes de configuration d'API 2 et 3 [SWS_NvM_00560], [SWS_NvM_00561].

Déroulement et synchronisation

Dès la mise en file d'attente réussie de la tâche ou le début du traitement, le bloc RAM permanent est immédiatement invalidé [SWS_NvM_00767]. Si une synchronisation explicite est configurée pour le bloc, l'application est autorisée à modifier le bloc RAM jusqu'à l'arrivée de la routine de synchronisation ; dans ce cas, l'invalidation a lieu directement avant l'appel de NvMReadRamBlockFromNvCallback [SWS_NvM_00706], [SWS_NvM_00767]. Si les données NV ont été transférées sans erreur dans la RAM, la tâche se termine avec l'état NVM_REQ_OK [SWS_NvM_00765], [SWS_NvM_00775].

Traitement des erreurs et redondance

Pour les blocs de type NVM_BLOCK_REDUNDANT, la tâche démarre automatiquement une tentative de lecture sur le deuxième bloc si la première tentative de lecture échoue [SWS_NvM_00768]. Pour les datasets (NVM_BLOCK_DATASET), la copie est empêchée si le bloc NV sélectionné via l'index est incohérent [SWS_NvM_00771] ; si l'index renvoie à des données ROM, celles-ci sont chargées et le résultat est défini à NVM_REQ_OK [SWS_NvM_00772]. Si des données par défaut sont configurées et que le bloc NV n'est pas lisible avec un état de RAM non valide, une restauration implicite a lieu [SWS_NvM_00575], qui classe le bloc RAM comme valide ainsi que modifié [SWS_NvM_00774] ; sans valeurs par défaut configurées, la restauration n'a pas lieu [SWS_NvM_00572]. Si NvM_SetBlockLockStatus était préalablement actif, le rechargement depuis la mémoire NV est forcé [SWS_NvM_00752].

La fonction réentrante et asynchrone NvM_WritePRAMBlock déclenche l'écriture des données d'un bloc RAM permanent dans le bloc NV associé [SWS_NvM_00793], [SWS_NvM_00794]. La fonction est disponible dans les classes de configuration d'API 2 et 3 [SWS_NvM_00561], [SWS_NvM_00560]. L'ID de bloc réservé 1 ne doit être transmis que si NvMDynamicConfiguration est défini sur TRUE [SWS_NvM_00311].

Lors de la transmission, la fonction fournit E_OK en cas d'acceptation réussie ou E_NOT_OK [SWS_NvM_00793]. Si le bloc référencé est verrouillé, l'appel échoue avec E_NOT_OK et le module signale une erreur DET [SWS_NvM_00797]. Une protection de bloc est déjà vérifiée lors de la mise en file d'attente des tâches et n'est pas revalidée avant l'exécution de la tâche [SWS_NvM_00799]. Si le bloc NVRAM possède une priorité immédiate (immediate priority), une tâche en cours est immédiatement interrompue de manière destructive et cette tâche d'écriture est traitée en premier [SWS_NvM_00800].

Avant le transfert proprement dit vers la mémoire NV, la tâche demande un recalcul de CRC si le bloc est configuré avec CRC [SWS_NvM_00801]. Un bloc RAM permanent encore non valide est automatiquement validé [SWS_NvM_00803]. Pour les blocs redondants (NVM_BLOCK_REDUNDANT), les deux blocs NV sont écrits, en commençant par celui qui n'a pas été lu lors des tâches de lecture précédentes [SWS_NvM_00807], [SWS_NvM_00808]. En cas d'erreurs d'écriture, le nombre de répétitions est limité par NVM_MAX_NUM_OF_WRITE_RETRIES [SWS_NvM_00806] ; en cas de dépassement, le NvM définit le résultat de la tâche à NVM_REQ_NOT_OK [SWS_NvM_00804] et signale NVM_E_REQ_FAILED au DEM [SWS_NvM_00805].

Concernant la concurrence : en cas de synchronisation implicite, l'application ne doit plus modifier les données du tampon après l'appel jusqu'à la fin de la tâche, l'accès en lecture restant autorisé [SWS_NvM_00698]. En cas de synchronisation explicite, le tampon peut être modifié jusqu'à ce que la routine de rappel NvMWriteRamBlockToNvCallback soit appelée [SWS_NvM_00705].

Utilisation et sémantique

La fonction NvM_RestorePRAMBlockDefaults restaure des données par défaut dans le bloc RAM permanent associé ([SWS_NvM_00813], [SWS_NvM_00814]). Le service fonctionne de manière asynchrone et prend en charge, via le paramètre BlockId, l'identifiant du descripteur de bloc NVRAM ([SWS_NvM_00813]). Lors de l'appel, la requête est placée dans la file d'attente de tâches interne ([SWS_NvM_00815]). La valeur de retour E_OK signale l'acceptation réussie, tandis que E_NOT_OK indique un rejet ([SWS_NvM_00813]). Si un bloc ROM est configuré, les données sont chargées à partir de celui-ci dans le cadre du traitement asynchrone ([SWS_NvM_00816]).

Gestion des erreurs et conditions limites

Si ni des données par défaut de ROM ni une routine de rappel NvMInitBlockCallback ne sont enregistrées pour le bloc, l'état du bloc reste inchangé et l'appel renvoie E_NOT_OK ([SWS_NvM_00884]). Lorsque la détection des erreurs de développement (DET) est activée, des erreurs spécifiques sont signalées :

• NVM_E_UNINIT : le module n'est pas encore initialisé ([SWS_NvM_00831]).
• NVM_E_PARAM_BLOCK_ID : le BlockId transmis se situe en dehors de la plage valide ([SWS_NvM_00834]).
• NVM_E_BLOCK_PENDING : une tâche est déjà en file d'attente ou en cours de traitement pour l'ID de bloc ([SWS_NvM_00832]).
• NVM_E_BLOCK_WITHOUT_DEFAULTS : il n'existe ni données par défaut de ROM ni rappel d'initialisation ([SWS_NvM_00886]).
• NVM_E_PARAM_ADDRESS : ni un bloc RAM permanent ni une synchronisation explicite ne sont configurés ([SWS_NvM_00894]).

Concurrence et interaction

Le service est spécifié comme non réentrant ([SWS_NvM_00813]) et est disponible dans les classes de configuration d'API 2 et 3 ([SWS_NvM_00561], [SWS_NvM_00560]). La même logique de restauration est également utilisée en interne lors de NvM_ReadPRAMBlock si l'opération de lecture sous-jacente échoue ([SWS_NvM_00789], [SWS_NvM_00882]).

La fonction NvM_ReadAll déclenche de manière asynchrone une requête de lecture multi-blocs pour l'initialisation des blocs de données RAM [SWS_NvM_00460], [SWS_NvM_00158]. Elle ne comporte aucun paramètre, ne renvoie aucune valeur de retour et n'est pas réentrante [SWS_NvM_00460]. L'appel signale la demande au module NvM et retourne immédiatement ; le traitement proprement dit est toutefois différé jusqu'à ce que toutes les files d'attente de requêtes de blocs individuels soient vides [SWS_NvM_00243].

Au début, la requête valide l'ID de configuration pendant le démarrage du système en comparant la valeur enregistrée à la valeur compilée [SWS_NvM_00073], [SWS_NvM_00246] :

• En cas de correspondance, la préparation normale a lieu pour tous les blocs configurés [SWS_NvM_00247].
• Une différence de configuration est ignorée lorsque NvMDynamicConfiguration == FALSE est défini [SWS_NvM_00248].
• Si NvMDynamicConfiguration == TRUE et NvMResistantToChangedSw == FALSE, une préparation étendue est exécutée en cas de non-concordance [SWS_NvM_00249].

La requête itère ensuite sur tous les blocs utilisateur, en commençant par l'ID de bloc le plus bas (à l'exception des ID réservés 0 et 1) [SWS_NvM_00244]. Sont pris en compte les blocs de RAM permanents ou les blocs avec callback de synchronisation configuré NvM_ReadRamBlockFromNvm, pour autant que NvmSelectBlockForReadall == TRUE soit configuré [SWS_NvM_00118]. Les blocs sélectionnés mais non lus reçoivent le résultat NVM_REQ_BLOCK_SKIPPED [SWS_NvM_00287].

Pour les blocs redondants (NVM_BLOCK_REDUNDANT), le deuxième bloc NV est lu automatiquement en cas d'échec de la première tentative de lecture [SWS_NvM_00288]. Après un chargement réussi dans la RAM, l'état du bloc est défini sur « valid/unmodified » et le résultat de la requête sur NVM_REQ_OK [SWS_NvM_00251], [SWS_NvM_00290], [SWS_NvM_00291]. Pour les blocs comportant NvMCalRamBlockCrC == TRUE, la requête demande un recalcul du CRC [SWS_NvM_00292]. S'il est configuré, NvMSingleBlockCallback est appelé pour chaque bloc et MultiBlockCallback après le dernier bloc [SWS_NvM_00281].

Utilisation et contexte d'appel

La fonction NvM_WriteAll déclenche de manière asynchrone une requête d'écriture multi-blocs et ne possède ni paramètres ni valeurs de retour [SWS_NvM_00461]. Après l'appel, la fonction signale la demande au module NvM et retourne immédiatement [SWS_NvM_00254]. Le traitement effectif est différé jusqu'à ce que toutes les files d'attente pour les requêtes de blocs individuels soient entièrement traitées [SWS_NvM_00254]. L'appel intervient typiquement dans le cadre de la procédure d'arrêt fondamental (Shutdown) par le BSW Mode Manager [SWS_NvM_00092].

Déroulement et traitement des blocs

Pendant le shutdown, la requête synchronise les blocs de RAM permanents avec les blocs NV associés ou exécute le callback de synchronisation explicite NvM_WriteRamBlockToNvm [SWS_NvM_00018]. Seuls les blocs pour lesquels le paramètre de configuration NvMSelectBlockForWriteAll est défini sur true sont pris en compte [SWS_NvM_00252], ainsi que le bloc 1 en cas d'ID de configuration divergents lorsque la configuration dynamique est active [SWS_NvM_00310]. Si un CRC est configuré pour un bloc NVRAM, la requête demande un recalcul avant l'opération d'écriture et met à jour la somme de contrôle [SWS_NvM_00253]. Pour les blocs comportant NvMWriteBlockOnce == TRUE, la requête positionne immédiatement l'indicateur de protection en écriture dans le bloc administratif après une écriture réussie [SWS_NvM_00329].

Concurrence et traitement des erreurs

• Réentrance : la fonction n'est pas réentrante [SWS_NvM_00461].
• Surveillance des erreurs : afin d'éviter les boucles infinies, un compteur de tentatives surveille les nouvelles tentatives en cas de retours infructueux du module MemIf [SWS_NvM_00296].
• Résultats de la requête : si le traitement d'au moins un bloc échoue, le résultat global est défini sur NVM_REQ_NOT_OK [SWS_NvM_00318]. Pour les blocs configurés qui n'ont pas été écrits, le résultat individuel NVM_REQ_BLOCK_SKIPPED est attribué [SWS_NvM_00298]. Pour les blocs redondants (NVM_BLOCK_REDUNDANT), la requête individuelle est considérée comme NVM_REQ_OK dès que l'un au moins des blocs NV a été écrit avec succès [SWS_NvM_00337].
• Interruption : une requête en cours peut être interrompue par NvM_CancelWriteAll [SWS_NvM_00019]. Cela conduit au résultat global NVM_REQ_CANCELED [SWS_NvM_00237], le bloc en cours de traitement étant mené à terme de manière non destructive et avec cohérence des données [SWS_NvM_00238].

Utilisation et sémantique

La fonction NvM_CancelWriteAll sert à interrompre prématurément une opération d'écriture multibloc en cours (NvM_WriteAll) [SWS_NvM_00458], [SWS_NvM_00019]. L'appel est asynchrone, non réentrant, n'accepte aucun paramètre et ne renvoie aucune valeur de retour [SWS_NvM_00458]. La fonction signale la demande d'interruption directement au module et retourne immédiatement [SWS_NvM_00232]. La demande n'est pas placée dans la file d'attente des tâches ; une seule demande de ce type peut être en attente à la fois [SWS_NvM_00420]. Si aucune opération n'est active au moment de l'appel, l'appel reste sans effet [SWS_NvM_00233].

Déroulement et cohérence des données

L'annulation est exécutée de manière à ne pas compromettre la cohérence des données du bloc NVRAM en cours de traitement au moment de l'annulation [SWS_NvM_00019]. Le module termine ce bloc actif de façon régulière et définit son attribut d'état, selon le succès, à NVM_REQ_OK ou NVM_REQ_NOT_OK, tandis que tous les blocs restants en attente sont définis à NVM_REQ_CANCELED [SWS_NvM_00236]. Le résultat global est implicitement prédéfini par le résultat de l'opération annulée [SWS_NvM_00235], est stocké dans une variable distincte [SWS_NvM_00393] et peut être interrogé via NvM_GetErrorStatus en spécifiant l'ID de bloc réservé 0 [SWS_NvM_00394]. De plus, un rappel de niveau supérieur (NvMMultiBlockCallback) peut être notifié en option [SWS_NvM_00260]. Si configuré via NvMDrvModeSwitch, la tâche commute les périphériques de stockage vers le mode de fonctionnement lent (« slow-mode ») après l'annulation [SWS_NvM_00681].

Restrictions et traitement des erreurs

L'appel de NvM_CancelWriteAll est fonctionnellement restreint et ne doit être effectué que par le BSW Mode Manager (BswM) [SWS_NvM_00703]. De plus, la fonction appartient à la classe de configuration d'API 2 [SWS_NvM_00561]. Le module doit avoir été initialisé avant l'appel [SWS_NvM_00716] ; lorsque la détection des erreurs de développement (DET) est activée, un appel à l'état non initialisé entraîne le message d'erreur NVM_E_UNINIT [SWS_NvM_00637].

La fonction NvM_ValidateAll déclenche la validation asynchrone de plusieurs blocs NVRAM ([SWS_NvM_00855]) et appartient à la classe de configuration d'API 3 ([SWS_NvM_00560]). Elle n'est pas réentrante, n'attend aucun paramètre et ne fournit aucune valeur de retour ([SWS_NvM_00855]). Avant l'appel, le module NvM doit être initialisé ([SWS_NvM_00859]).

Lors de l'appel, la fonction signale la requête au module et retourne immédiatement ([SWS_NvM_00858]). Le traitement effectif est toutefois différé jusqu'à ce que toutes les files d'attente de tâches de blocs individuels soient entièrement traitées ([SWS_NvM_00858]). Pour les tâches multiblocs, un seul emplacement au total est disponible dans la file d'attente de tâches ([SWS_NvM_00380]). Le résultat global de la tâche asynchrone est conservé dans une variable d'état distincte ([SWS_NvM_00393]).

Dans le cadre du traitement de la tâche, le résultat multibloc ainsi que les résultats des blocs individuels concernés sont préalablement définis à NVM_REQ_PENDING ([SWS_NvM_00861]). Le traitement prend exclusivement en compte les blocs pour lesquels NvMBlockUseAutoValidation est configuré sur TRUE ([SWS_NvM_00856], [SWS_NvM_00860]) :

• Des blocs RAM permanents sont traités ou la synchronisation explicite est exécutée via le rappel NvM_WriteRamBlockToNvm ([SWS_NvM_00860]).
• L'état du bloc RAM est défini à « VALID / CHANGED » ([SWS_NvM_00856]).
• Si un calcul de CRC en RAM est en outre configuré, la tâche demande le recalcul en arrière-plan, qui est traité via NvM_MainFunction ([SWS_NvM_00857]).
• Après la validation réussie du bloc RAM, le résultat spécifique au bloc passe à NVM_REQ_OK ([SWS_NvM_00862]).

La fonction NvM_FirstInitAll déclenche l'initialisation initiale asynchrone de plusieurs blocs configurés ([SWS_NvM_91001]). Le service n'est pas réentrant, n'attend aucun paramètre et ne fournit aucune valeur de retour ([SWS_NvM_91001]). Lors du traitement, il n'est pas pris en compte si un bloc existe déjà dans la mémoire non volatile ou s'il est valide ou corrompu ([SWS_NvM_91001]). La longueur de la file d'attente pour les tâches multiblocs (provenant entre autres de NvM_FirstInitAll) est de un, de sorte qu'une seule tâche multibloc peut être mise en file d'attente en même temps ([SWS_NvM_00380]).

Le traitement diffère selon le type de gestion du bloc :

• NATIVE : Si des données par défaut sont présentes, le bloc NV est écrit avec celles-ci ([SWS_NvM_00913]). Si le bloc possède de la RAM permanente ou une synchronisation explicite, la RAM est mise à jour avec les données par défaut (ROM ou rappel d'initialisation) comme lors de NvM_RestoreBlockDefaults ([SWS_NvM_00915]) ; sans RAM permanente et sans synchronisation explicite, le tampon interne du NvM sert de RAM, l'état de la RAM restant inchangé ([SWS_NvM_00914]). Si des données par défaut manquent ([SWS_NvM_00919]) ou si un rappel d'initialisation configuré échoue avec une valeur de retour différente de E_OK ([SWS_NvM_00921]), le bloc est invalidé.
• REDUNDANT : Si des données par défaut sont présentes, les deux instances de bloc sont écrites avec celles-ci ([SWS_NvM_00916]) et la RAM est mise à jour en présence de RAM permanente ou de synchronisation explicite ([SWS_NvM_00918]) ; sinon, le tampon interne est utilisé ([SWS_NvM_00917]). Si un rappel d'initialisation ne renvoie pas E_OK, les deux instances sont invalidées ([SWS_NvM_00922]).
• DATASET : Tous les blocs ou instances de blocs NV de ce type configurés pour le traitement sont sans exception invalidés ([SWS_NvM_00923], [SWS_NvM_00924]).

Si l'écriture d'un bloc NATIVE avec des données par défaut ([SWS_NvM_00925]), l'invalidation d'un bloc NATIVE ([SWS_NvM_00927]) ou l'écriture des deux instances d'un bloc REDUNDANT ([SWS_NvM_00926]) échoue, la tâche définit le résultat global à NVM_REQ_NOT_OK.

Utilisation

La fonction de rappel synchrone NvM_JobEndNotification est appelée par l'abstraction de mémoire sous-jacente pour signaler au gestionnaire NVRAM la fin sans erreur d'une tâche [SWS_NvM_00462]. La fonction n'a ni paramètres ni valeur de retour et est disponible via le fichier d'en-tête NvM_MemIf.h avec le Service-ID 0x11 [SWS_NvM_00462]. Une notification réussie de l'abstraction de mémoire comprend des opérations de lecture, d'écriture ou d'effacement achevées sans erreur [SWS_NvM_00111].

Concurrence et restrictions

L'interface est spécifiée comme non réentrante [SWS_NvM_00462]. En fonction de la fonction appelante au sein de l'abstraction de mémoire, cette routine peut être exécutée dans le contexte d'interruption [SWS_NvM_00111]. Tous les modules de l'abstraction de mémoire doivent être configurés de manière à utiliser uniformément le même mode – rappel ou scrutation (polling) – [SWS_NvM_00111].

Configuration et interaction

Le module NvM ne fournit la fonction de rappel NvM_JobEndNotification que si le mode de scrutation (polling) est désactivé via le paramètre de configuration NvMPollingMode [SWS_NvM_00440]. De plus, la fonction est influencée par des paramètres généraux de configuration de NvM [SWS_NvM_00440].

La fonction de rappel NvM_JobErrorNotification ([SWS_NvM_00463]) sert à la couche d'abstraction de mémoire sous-jacente à signaler la fin en erreur d'une tâche asynchrone au module gestionnaire NVRAM (NvM). L'appel s'effectue de manière synchrone et est spécifié comme non réentrant ([SWS_NvM_00463]).

Utilisation et signature

• Interface : La déclaration de la fonction est mise à disposition via le fichier d'en-tête NvM_MemIf.h ([SWS_NvM_00463]).
• Signature : Conformément à void NvM_JobErrorNotification(void), la fonction ne comporte aucun paramètre d'entrée, de sortie ou d'entrée/sortie et ne fournit aucune valeur de retour ([SWS_NvM_00463]).
• Service-ID : La fonction est identifiée par l'identifiant hexadécimal 0x12 ([SWS_NvM_00463]).

Dépendance vis-à-vis de la configuration et interaction

Le module NvM ne fournit la fonction de rappel NvM_JobErrorNotification que si le mode de scrutation (polling) est désactivé via le paramètre de configuration NvMPollingMode ([SWS_NvM_00441]). Si le polling est utilisé, ce mécanisme de notification n'est pas applicable. En outre, la fonction est influencée par les paramètres généraux de configuration selon [SWS_NvM_00028] libellé pas encore importé ([SWS_NvM_00441]).

Gestion des erreurs et concurrence

La fonction sert exclusivement à la notification d'erreur des tâches et ne définit ni codes d'erreur propres ni retours DET ou DEM ([SWS_NvM_00463]). En raison de la classification en tant que Non Reentrant, il incombe vraisemblablement à l'appelant dans l'abstraction de mémoire de s'assurer qu'aucun appel chevauchant ou interruptif n'ait lieu ([SWS_NvM_00463]). Question Q-5f72d9d605c25922 (ouverte)

Utilisation

La fonction NvM_MainFunction ne comporte ni paramètres de transmission ni valeur de retour (void NvM_MainFunction(void)) et est déclarée via SchM_NvM.h ([SWS_NvM_00464]). Elle sert au traitement des tâches du gestionnaire NVRAM ([SWS_NvM_00464], [SWS_NvM_00256]). Après l'achèvement d'un service asynchrone, elle exécute des routines de rappel configurées pour notifier la couche supérieure ([SWS_NvM_00347]). De plus, elle prend en charge en arrière-plan les recalculs de CRC demandés pour les blocs NVRAM ([SWS_NvM_00333]), par exemple à la suite de NvM_SetRamBlockStatus ([SWS_NvM_00121]) ou de NvM_ValidateAll ([SWS_NvM_00857]).

Contrôle du déroulement et priorisation

Si configurée, la fonction surveille la file d'attente à priorité immédiate (Immediate-Priority-Queue) pour détecter les requêtes à priorité immédiate ([SWS_NvM_00259]). Si une requête régulière a été interrompue de manière destructive par une tâche immédiate, NvM_MainFunction la redémarre après l'achèvement de celle-ci ([SWS_NvM_00258]). Lorsque le mode de scrutation (polling) est actif, elle vérifie l'état des tâches transmises à la couche inférieure ([SWS_NvM_00346]). Pendant le traitement de NvM_WriteAll, elle interroge cycliquement l'état de l'abstraction des pilotes de mémoire via MemIf_GetStatus pour MEMIF_BROADCAST_ID et retient les rappels vers la couche supérieure tant que MEMIF_BUSY_INTERNAL est signalé ([SWS_NvM_00350]).

Traitement des erreurs et répétitions

Si des rappels spécifiques à l'application échouent, NvM_MainFunction contrôle les tentatives de relance :

• Si NvMReadRamBlockFromNvCallback renvoie la valeur E_NOT_OK, le module répète l'appel au cycle suivant de NvM_MainFunction ([SWS_NvM_00839]).
• Si NvMWriteRamBlockToNvCallback retourne E_NOT_OK, la répétition a également lieu lors de l'appel suivant de NvM_MainFunction ([SWS_NvM_00840]).
• Si le rappel de synchronisation explicite renvoie E_NOT_OK lors de NvM_SetRamBlockStatus, le module exécute les répétitions configurées à raison d'une tentative par appel de NvM_MainFunction ([SWS_NvM_00908]).

Utilisation

La routine de rappel NvM_SingleBlockCallbackFunction notifie la couche supérieure de manière synchrone de l'achèvement d'une requête asynchrone sur un bloc individuel préalablement déclenchée [SWS_NvM_00467].

La fonction traite deux paramètres de transmission [SWS_NvM_00467] :

• BlockRequest (type NvM_BlockRequestType) : transmet le type de requête de bloc préalablement exécutée, tel que par exemple des opérations de lecture ou d'écriture [SWS_NvM_00467].
• JobResult (type NvM_RequestResultType) : signale le résultat global de la tâche de bloc traitée [SWS_NvM_00467].

Comme valeur de retour, la fonction fournit le type Std_ReturnType [SWS_NvM_00467]. Un traitement réussi du rappel est signalé par le retour de E_OK ; toute autre valeur de retour caractérise une exécution non réussie [SWS_NvM_00467].

Gestion des erreurs et concurrence

L'interface ne spécifie aucun message d'erreur DET ou DEM propre [SWS_NvM_00467]. Le résultat de la tâche précédente est transmis via le paramètre JobResult, tandis que les erreurs au sein du traitement du rappel lui-même sont signalées via la valeur de retour de la fonction [SWS_NvM_00467].

Concernant la concurrence, la routine est déclarée comme non réentrante (Non Reentrant) [SWS_NvM_00467]. Elle est mise à disposition via l'en-tête NvM_Externals.h [SWS_NvM_00467]. L'appel par le module NvM devrait avoir lieu de manière synchrone dans le contexte de tâche du traitement cyclique des tâches de NvM (interprétation). Question Q-f50640211851274f (ouverte)

La routine de rappel NvM_MultiBlockCallbackFunction notifie la couche supérieure du fait qu'une tâche multibloc asynchrone préalablement initiée a été achevée [SWS_NvM_00468]. La déclaration de la fonction est mise à disposition via le fichier d'en-tête NvM_Externals.h [SWS_NvM_00468].

Contexte d'appel et paramètres

L'appel par le gestionnaire NVRAM s'effectue de manière synchrone avec le traitement dans le déroulement de traitement [SWS_NvM_00468]. Lors de l'appel, deux paramètres sont transmis à la routine :

• MultiBlockRequest (type NvM_MultiBlockRequestType) : désigne le type de requête concret de la tâche multibloc préalablement traitée, comme par exemple des accès en lecture ou en écriture [SWS_NvM_00468].
• JobResult (type NvM_RequestResultType) : transmet le résultat final du traitement du job multibloc précédent à la couche supérieure [SWS_NvM_00468].

Valeur de retour et traitement des erreurs

La routine renvoie une valeur de type Std_ReturnType au module appelant [SWS_NvM_00468]. La valeur de retour E_OK indique que la fonction de rappel a pu être traitée avec succès ; toute autre valeur de retour signale en revanche un échec de traitement [SWS_NvM_00468]. Les codes d'erreur spécifiques, messages DET ou DEM ne sont pas définis dans le périmètre de la spécification pour cette fonction. Interprétation : les conséquences concrètes d'une valeur de retour différente de E_OK devraient être spécifiques à l'implémentation, étant donné que la norme ne prescrit aucun traitement d'erreur en aval. Question Q-462dea7f3074ae9c (ouverte)

Concurrence et restrictions

La fonction est spécifiée comme non réentrante (Non Reentrant) [SWS_NvM_00468]. Au sein du système appelant, il doit donc être garanti qu'aucun appel multiple concurrent ou interruptif de cette interface de rappel n'ait lieu.

Utilisation et contexte d'appel

La routine de rappel spécifique à l'utilisateur NvM_InitBlockCallbackFunction est appelée par le module NvM lorsque des données par défaut doivent être restaurées en RAM pour un bloc NVRAM et qu'aucun bloc ROM correspondant n'est configuré [SWS_NvM_00469]. L'appel a lieu de manière synchrone et l'interface est déclarée via l'en-tête NvM_Externals.h [SWS_NvM_00469].

En tant que paramètre de transmission, la fonction reçoit InitBlockRequest de type NvM_InitBlockRequestType [SWS_NvM_00469]. Cette valeur informe la routine sur le type de requête spécifique du bloc en cours de traitement, comme par exemple la lecture ou la restauration de données (read, restore) [SWS_NvM_00469].

Valeurs de retour et gestion des erreurs

La routine renvoie une valeur d'état de type Std_ReturnType [SWS_NvM_00469] :

• E_OK : signale au module NvM que la fonction de rappel a initialisé et traité avec succès les données en RAM [SWS_NvM_00469].
• Toute autre valeur de retour : indique que l'initialisation n'a pas pu être achevée avec succès [SWS_NvM_00469].

Des codes d'erreur spécifiques pour DET ou DEM ne sont pas spécifiés pour l'interface elle-même [SWS_NvM_00469].

Concurrence et restrictions d'exécution

L'interface est définie comme synchrone et non réentrante (Non Reentrant) [SWS_NvM_00469]. Comme le gestionnaire NVRAM attend de manière synchrone le retour de la fonction, une exécution bloquante au sein de la routine devrait immédiatement suspendre la poursuite du traitement du NvM (interprétation). Question Q-c0e43c9871c4f2d0 (ouverte)

La fonction de rappel spécifique au bloc NvM_WriteRamBlockToNvm sert à la synchronisation explicite afin de copier des données d'application depuis le bloc RAM vers le miroir RAM interne du module NvM [SWS_NvM_00539]. Elle est disponible déclarativement via NvM_Externals.h et est appelée de manière synchrone par le NvM [SWS_NvM_00539].

Utilisation et paramètres

La fonction transmet en paramètre de sortie le pointeur NvMBuffer, qui représente l'adresse de destination du miroir NvM à laquelle les données doivent être écrites [SWS_NvM_00539]. Comme valeur de retour, la routine de rappel fournit E_OK en cas de traitement réussi ou toute autre valeur en cas de déroulement erroné [SWS_NvM_00539].

Concurrence et restrictions

Conformément à la spécification, NvM_WriteRamBlockToNvm est conçue comme non réentrante (Non Reentrant) [SWS_NvM_00539].

Interaction au sein du module

• Lors de l'arrêt, le job NvM_WriteAll synchronise des blocs RAM permanents ou appelle la routine de rappel NvM_WriteRamBlockToNvm pour la synchronisation explicite [SWS_NvM_00018], pour autant que le paramètre NvMSelectBlockForWriteAll pour le bloc NVRAM soit configuré sur true [SWS_NvM_00252].
• Les jobs d'écriture NvM_WriteBlock [SWS_NvM_00303] et NvM_WritePRAMBlock [SWS_NvM_00803] valident automatiquement un bloc RAM permanent encore non valide après l'appel de NvM_WriteRamBlockToNvm.

La fonction NvM_ReadRamBlockFromNvm est une routine de rappel spécifique au bloc qui est déclarée via NvM_Externals.h [SWS_NvM_00540]. Son but consiste à permettre à l'application de copier des données depuis le tampon miroir interne du module NvM vers le bloc RAM associé, afin d'effectuer une synchronisation explicite [SWS_NvM_00540], [SWS_NvM_00118].

Utilisation et sémantique

• Contexte d'appel et concurrence : L'appel s'effectue de manière synchrone et est spécifié comme non réentrant (Non Reentrant) [SWS_NvM_00540].
• Paramètres : Le pointeur NvMBuffer (type const void*) sert de paramètre de transmission. Il transmet l'adresse du tampon à partir de laquelle les données peuvent être lues et copiées dans le bloc RAM [SWS_NvM_00540].
• Valeur de retour et traitement des erreurs : La fonction de rappel renvoie un Std_ReturnType. La valeur de retour E_OK signale le traitement réussi ; toute autre valeur de retour indique un traitement non réussi [SWS_NvM_00540].

Interaction

Dans le cadre du service multibloc NvM_ReadAll, NvM_ReadRamBlockFromNvm est appelée pour la synchronisation explicite pour les blocs NVRAM qui sont configurés de manière correspondante et pour lesquels NvmSelectBlockForReadall == TRUE s'applique [SWS_NvM_00118], [SWS_NvM_00356]. Cela représente l'alternative à l'opération de copie directe dans des blocs RAM permanents, tandis que NvM_ReadAll initialise les données de gestion des blocs [SWS_NvM_00356].

Le type énumération NvM_MultiBlockRequestType est mis à disposition via le fichier d'en-tête NvM.h et sert à l'identification univoque d'une requête multibloc exécutée [SWS_NvM_91003]. Le type est utilisé lorsque le résultat ou l'état d'une opération multibloc est signalé via une fonction de rappel ou notifié au module BswM [SWS_NvM_91003].

Plage de valeurs et sémantique

L'énumération définit les valeurs suivantes pour différencier les tâches multiblocs [SWS_NvM_91003] :

• NVM_READ_ALL (0x00) : indique que NvM_ReadAll a été exécuté.
• NVM_WRITE_ALL (0x01) : indique que NvM_WriteAll a été exécuté.
• NVM_VALIDATE_ALL (0x02) : indique que NvM_ValidateAll a été exécuté.
• NVM_FIRST_INIT_ALL (0x03) : indique que NvM_FirstInitAll a été exécuté.
• NVM_CANCEL_WRITE_ALL (0x04) : indique que NvM_CancelWriteAll a été exécuté.

Interaction

La transmission de ce type permet aux callbacks appelés ainsi qu'au BswM de déterminer quel service multi-blocs concret a déclenché la notification. Interprétation : la notification en retour au BswM sert vraisemblablement à coupler des actions consécutives ou des changements d'état dans le système global à l'achèvement de services multi-blocs spécifiques. Question Q-69b4d985301acfeb (ouverte)

Le type NvM_RequestResultType repose sur uint8, est disponible via Rte_NvM_Type.h et représente le résultat de demande asynchrone des requêtes de lecture, d'écriture et de commande du gestionnaire NVRAM [SWS_NvM_00470]. Le résultat est principalement interrogé via le service API NvM_GetErrorStatus et peut en outre être signalé par le biais d'une fonction de callback configurée [SWS_NvM_00470].

La plage de valeurs représente différents états d'exécution et cas d'erreur [SWS_NvM_00470] :

• NVM_REQ_OK (0x00) : la dernière requête asynchrone s'est achevée avec succès ; il s'agit également de la valeur par défaut après une réinitialisation.
• NVM_REQ_NOT_OK (0x01) : la demande asynchrone de lecture, d'écriture ou de commande ne s'est pas achevée avec succès.
• NVM_REQ_PENDING (0x02) : une demande asynchrone est actuellement encore en cours de traitement.
• NVM_REQ_INTEGRITY_FAILED (0x03) : erreur d'intégrité des données lors de NvM_ReadBlock ou NvM_ReadAll. Dans le cas de NvM_ReadBlock, le contenu du bloc de RAM a été modifié mais est devenu invalide ; il incombe à l'application de renouveler et de valider le contenu.
• NVM_REQ_BLOCK_SKIPPED (0x04) : le bloc référencé a été ignoré pendant NvM_ReadAll ou NvM_WriteAll (par ex. les blocs NVRAM de type jeu de données lors de NvM_ReadAll ou les blocs sans bloc de RAM configuré comme permanent).
• NVM_REQ_NV_INVALIDATED (0x05) : le bloc NV référencé est invalidé.
• NVM_REQ_CANCELED (0x06) : annulation de NvM_WriteAll par NvM_CancelWriteAll ou annulation d'une requête de bloc individuel (NvM_ReadBlock, NvM_WriteBlock, NvM_EraseNvBlock, NvM_InvalidateNvBlock, NvM_RestoreBlockDefaults) par NvM_CancelJobs.
• NVM_REQ_RESTORED_DEFAULTS (0x08) : les valeurs par défaut ont été copiées avec succès dans l'image RAM.

En combinaison avec des blocs redondants (NVM_BLOCK_REDUNDANT), la fonction NvM_InvalidateNvBlock ne définit le résultat de la demande NvM_RequestResultType sur NVM_REQ_OK que lorsque les deux blocs NV ont été invalidés [SWS_NvM_00274].

Le type de données NvM_InitBlockRequestType repose sur uint8 et est mis à disposition via le fichier d'en-tête Rte_NvM_Type.h [SWS_NvM_91123]. Il sert à identifier le type de la requête exécutée sur un bloc NVRAM lorsque celle-ci est signalée via une fonction de callback correspondante [SWS_NvM_91123].

La plage de valeurs autorisée comprend quatre types de requêtes [SWS_NvM_91123] :

• NVM_INIT_READ_BLOCK (0x00) : indique que NvM_ReadBlock ou NvM_ReadPRAMBlock a été demandé pour le bloc [SWS_NvM_91123].
• NVM_INIT_RESTORE_BLOCK_DEFAULTS (0x01) : signale que NvM_RestoreBlockDefaults ou NvM_RestorePRAMBlockDefaults a été demandé pour le bloc [SWS_NvM_91123].
• NVM_INIT_READ_ALL_BLOCK (0x02) : indique que le traitement du bloc s'effectue dans le cadre de NvM_ReadAll [SWS_NvM_91123].
• NVM_INIT_FIRST_INIT_ALL (0x03) : caractérise le traitement du bloc pendant le déroulement de NvM_FirstInitAll [SWS_NvM_91123].

À partir de cette valeur d'énumération, la logique d'application appelée peut distinguer s'il s'agit d'une requête explicite de bloc individuel (lecture ou restauration de valeurs par défaut) ou d'une opération collective globale lors du démarrage du système [SWS_NvM_91123]. Interprétation : le type devrait être transmis comme paramètre aux callbacks d'initialisation liés au bloc, afin que l'application puisse fournir des données par défaut adaptées à la situation ou prendre des mesures préparatoires spécifiques. Question Q-42d0d469e305728e (ouverte)

Le type énuméré NvM_BlockRequestType est basé sur uint8 et est mis à disposition via l'en-tête Rte_NvM_Type.h [SWS_NvM_91002]. Il sert, lors d'une notification via une fonction de rappel, à transmettre le type de la requête qui a été préalablement exécutée sur un bloc NVRAM [SWS_NvM_91002].

La plage de valeurs comprend six requêtes de bloc spécifiques [SWS_NvM_91002] :

• NVM_READ_BLOCK (0x00) : signale que NvM_ReadBlock ou NvM_ReadPRAMBlock a été exécuté pour le bloc [SWS_NvM_91002].
• NVM_WRITE_BLOCK (0x01) : signale que NvM_WriteBlock ou NvM_WritePRAMBlock a été exécuté pour le bloc [SWS_NvM_91002].
• NVM_RESTORE_BLOCK_DEFAULTS (0x02) : signale que NvM_RestoreBlockDefaults ou NvM_RestorePRAMBlockDefaults a été exécuté [SWS_NvM_91002].
• NVM_ERASE_NV_BLOCK (0x03) : signale que NvM_EraseNvBlock a été exécuté sur le bloc [SWS_NvM_91002].
• NVM_INVALIDATE_NV_BLOCK (0x04) : signale que NvM_InvalidateNvBlock a été exécuté sur le bloc [SWS_NvM_91002].
• NVM_READ_ALL_BLOCK (0x05) : signale que NvM_ReadAll a achevé le traitement de ce bloc [SWS_NvM_91002].

Dans l'architecture applicative, la valeur devrait être évaluée comme paramètre dans les routines de rappel afin d'informer de manière différenciée les composants logiciels de niveau supérieur de la fin de certaines opérations de bloc [SWS_NvM_91002]. Question Q-467801b6b5e898a2 (ouverte) En l'absence d'autres exigences dans la charge utile concernant les codes d'erreur ou la concurrence, les détails de spécification se limitent à la définition de type et à la plage de valeurs [SWS_NvM_91002].