yuwenhao
/
Modbus-rtu
1
0
Форк 0
Код Проблеми 0 Запити на злиття 0 Релізи 0 Вікі Активність
Ви не можете вибрати більше 25 тем Теми мають розпочинатися з літери або цифри, можуть містити дефіси (-) і не повинні перевищувати 35 символів.
42 Коміти
3 Гілки
138 MiB
 
 
 
 
 
 
Дерево: f96f713e09
Гілки Теги
${ item.name }
Створити гілку ${ searchTerm }
з 'f96f713e09'
${ noResults }
Modbus-rtu/PLSR/Src/plsr_persistence.c

1183 рядки
36 KiB
Неформатований Звинувачення Історія 

  1. #include "plsr_persistence.h"

  2. #include "plsr_build_config.h"

  3. #include <stddef.h>

  4. #include <string.h>

  5. 

  6. #define PLSR_HSD_BACKUP_MAGIC          (0x504C4853UL)

  7. #define PLSR_HSD_BACKUP_VERSION        (2U)

  8. #define PLSR_BACKUP_SLOT_A_OFFSET      (0x0100UL)

  9. #define PLSR_BACKUP_SLOT_STRIDE        (0x0200UL)

  10. #define PLSR_SFD_FLASH_MAGIC           (0x504C5346UL)

  11. #define PLSR_SFD_FLASH_VERSION         (1U)

  12. #define PLSR_SFD_FLASH_SLOT_A_ADDRESS  (0x080C0000UL)

  13. #define PLSR_SFD_FLASH_SLOT_B_ADDRESS  (0x080E0000UL)

  14. #define PLSR_SFD_FLASH_SECTOR_SIZE     (0x00020000UL)

  15. #define PLSR_SFD_AXIS_STRIDE           (130U)

  16. #define PLSR_SFD_PARAMETER_SET_COUNT   (4U)

  17. #define PLSR_SFD_PARAMETER_SET_OFFSET  (50U)

  18. #define PLSR_SFD_PARAMETER_SET_STRIDE  (20U)

  19. #define PLSR_SFD_DEFAULT_MAX_SPEED     (100000UL)

  20. #define PLSR_SFD_DEFAULT_SPEED         (1000UL)

  21. #define PLSR_SFD_DEFAULT_ACCEL_MS      (100U)

  22. #define PLSR_SFD_DEFAULT_DECEL_MS      (100U)

  23. #define PLSR_SFD_DEFAULT_FOLLOW        (50U)

  24. #define PLSR_HSD_PARAMETER_SET_STRIDE  (20U)

  25. #define PLSR_HSD_DEFAULT_BASE          (460U)

  26. 

  27. static const uint32_t PlsrPersistenceCrc32Nibble[16] =

  28. {

  29.     0x00000000UL, 0x1DB71064UL, 0x3B6E20C8UL, 0x26D930ACUL,

  30.     0x76DC4190UL, 0x6B6B51F4UL, 0x4DB26158UL, 0x5005713CUL,

  31.     0xEDB88320UL, 0xF00F9344UL, 0xD6D6A3E8UL, 0xCB61B38CUL,

  32.     0x9B64C2B0UL, 0x86D3D2D4UL, 0xA00AE278UL, 0xBDBDF21CUL

  33. };

  34. 

  35. typedef struct

  36. {

  37.     uint32_t magic;

  38.     uint16_t version;

  39.     uint16_t payloadLength;

  40.     uint32_t generation;

  41.     PLSR_HSD_DATA data;

  42.     uint32_t crc32;

  43. } PLSR_HSD_BACKUP_RECORD;

  44. 

  45. typedef struct

  46. {

  47.     uint32_t magic;

  48.     uint16_t version;

  49.     uint16_t payloadLength;

  50.     uint32_t generation;

  51. } PLSR_SFD_FLASH_HEADER;

  52. 

  53. typedef struct

  54. {

  55.     uint32_t magic;

  56.     uint16_t version;

  57.     uint16_t payloadLength;

  58.     uint32_t generation;

  59.     PLSR_SFD_DATA data;

  60.     uint32_t crc32;

  61. } PLSR_SFD_FLASH_RECORD;

  62. 

  63. #ifdef PLSR_HOST_TEST

  64. static PLSR_HSD_BACKUP_RECORD PlsrHostBackupSlots[2];

  65. static PLSR_SFD_FLASH_RECORD PlsrHostSfdSlots[2];

  66. static PLSR_TEST_SFD_FAULT PlsrHostSfdFault;

  67. static uint32_t PlsrHostHsdSaveCount;

  68. #else

  69. #include "stm32f4xx.h"

  70. #include "stm32f4xx_hal.h"

  71. #include "stm32f4xx_hal_flash_ex.h"

  72. #endif

  73. 

  74. static PLSR_PERSISTENCE_DIAGNOSTICS PlsrPersistenceDiagnostics;

  75. static uint8_t PlsrPersistenceDiagnosticsInitialized;

  76. 

  77. static void PlsrPersistenceEnsureDiagnostics(void)

  78. {

  79.     if (PlsrPersistenceDiagnosticsInitialized == 0U)

  80.     {

  81.         (void)memset(&PlsrPersistenceDiagnostics,

  82.                      0,

  83.                      sizeof(PlsrPersistenceDiagnostics));

  84.         PlsrPersistenceDiagnostics.lastHsdLoadResult =

  85.             PLSR_PERSISTENCE_NOT_IMPLEMENTED;

  86.         PlsrPersistenceDiagnostics.lastSfdLoadResult =

  87.             PLSR_PERSISTENCE_NOT_IMPLEMENTED;

  88.         PlsrPersistenceDiagnostics.lastHsdSaveResult =

  89.             PLSR_PERSISTENCE_NOT_IMPLEMENTED;

  90.         PlsrPersistenceDiagnostics.lastSfdSaveResult =

  91.             PLSR_PERSISTENCE_NOT_IMPLEMENTED;

  92.         PlsrPersistenceDiagnostics.lastSfdEraseResult =

  93.             PLSR_PERSISTENCE_NOT_IMPLEMENTED;

  94. #if PLSR_ENABLE_DESTRUCTIVE_PERSISTENCE_DIAG != 0U

  95.         PlsrPersistenceDiagnostics.destructiveDiagnosticEnabled = 1U;

  96. #endif

  97.         PlsrPersistenceDiagnosticsInitialized = 1U;

  98.     }

  99. }

  100. 

  101. static uint32_t PlsrPersistenceCrc32Update(uint32_t crc,

  102.                                           const volatile uint8_t *data,

  103.                                           uint32_t length)

  104. {

  105.     uint32_t index;

  106. 

  107.     for (index = 0U; index < length; index++)

  108.     {

  109.         crc ^= data[index];

  110.         crc = (crc >> 4U)

  111.               ^ PlsrPersistenceCrc32Nibble[crc & 0x0FUL];

  112.         crc = (crc >> 4U)

  113.               ^ PlsrPersistenceCrc32Nibble[crc & 0x0FUL];

  114.     }

  115. 

  116.     return crc;

  117. }

  118. 

  119. static uint32_t PlsrPersistenceCrc32(const volatile uint8_t *data,

  120.                                     uint32_t length)

  121. {

  122.     return ~PlsrPersistenceCrc32Update(0xFFFFFFFFUL, data, length);

  123. }

  124. 

  125. static volatile PLSR_HSD_BACKUP_RECORD *PlsrPersistenceGetHsdSlot(

  126.     uint8_t slot)

  127. {

  128. #ifdef PLSR_HOST_TEST

  129.     return &PlsrHostBackupSlots[slot];

  130. #else

  131.     uint32_t offset = PLSR_BACKUP_SLOT_A_OFFSET

  132.                       + (uint32_t)slot * PLSR_BACKUP_SLOT_STRIDE;

  133.     return (volatile PLSR_HSD_BACKUP_RECORD *)(BKPSRAM_BASE + offset);

  134. #endif

  135. }

  136. 

  137. static uint8_t PlsrPersistenceHsdRecordIsValid(

  138.     const volatile PLSR_HSD_BACKUP_RECORD *record)

  139. {

  140.     uint32_t expectedCrc;

  141. 

  142.     if ((record->magic != PLSR_HSD_BACKUP_MAGIC)

  143.         || (record->version != PLSR_HSD_BACKUP_VERSION)

  144.         || (record->payloadLength != sizeof(PLSR_HSD_DATA)))

  145.     {

  146.         return 0U;

  147.     }

  148. 

  149.     expectedCrc = PlsrPersistenceCrc32(

  150.         (const volatile uint8_t *)record,

  151.         (uint32_t)offsetof(PLSR_HSD_BACKUP_RECORD, crc32));

  152. 

  153.     return (expectedCrc == record->crc32) ? 1U : 0U;

  154. }

  155. 

  156. static uint8_t PlsrPersistenceGenerationIsNewer(uint32_t left,

  157.                                                 uint32_t right)

  158. {

  159.     return (((int32_t)(left - right)) > 0) ? 1U : 0U;

  160. }

  161. 

  162. static volatile PLSR_SFD_FLASH_RECORD *PlsrPersistenceGetSfdSlot(

  163.     uint8_t slot)

  164. {

  165. #ifdef PLSR_HOST_TEST

  166.     return &PlsrHostSfdSlots[slot];

  167. #else

  168.     uint32_t address = (slot == 0U) ? PLSR_SFD_FLASH_SLOT_A_ADDRESS

  169.                                     : PLSR_SFD_FLASH_SLOT_B_ADDRESS;

  170.     return (volatile PLSR_SFD_FLASH_RECORD *)address;

  171. #endif

  172. }

  173. 

  174. static uint8_t PlsrPersistenceSfdRecordIsValid(

  175.     const volatile PLSR_SFD_FLASH_RECORD *record)

  176. {

  177.     uint32_t expectedCrc;

  178. 

  179.     if ((record->magic != PLSR_SFD_FLASH_MAGIC)

  180.         || (record->version != PLSR_SFD_FLASH_VERSION)

  181.         || (record->payloadLength != sizeof(PLSR_SFD_DATA)))

  182.     {

  183.         return 0U;

  184.     }

  185. 

  186.     expectedCrc = PlsrPersistenceCrc32(

  187.         (const volatile uint8_t *)record,

  188.         (uint32_t)offsetof(PLSR_SFD_FLASH_RECORD, crc32));

  189. 

  190.     return (expectedCrc == record->crc32) ? 1U : 0U;

  191. }

  192. 

  193. static uint8_t PlsrPersistenceNewestMask(uint8_t validA,

  194.                                          uint8_t validB,

  195.                                          uint32_t generationA,

  196.                                          uint32_t generationB)

  197. {

  198.     if ((validA != 0U) && (validB != 0U))

  199.     {

  200.         return (PlsrPersistenceGenerationIsNewer(generationB, generationA)

  201.                 != 0U)

  202.                    ? 2U

  203.                    : 1U;

  204.     }

  205.     if (validA != 0U)

  206.     {

  207.         return 1U;

  208.     }

  209.     return (validB != 0U) ? 2U : 0U;

  210. }

  211. 

  212. static void PlsrPersistenceUpdateHsdDiagnostics(

  213.     const volatile PLSR_HSD_BACKUP_RECORD *slotA,

  214.     const volatile PLSR_HSD_BACKUP_RECORD *slotB,

  215.     uint8_t validA,

  216.     uint8_t validB)

  217. {

  218.     uint8_t newestMask;

  219. 

  220.     PlsrPersistenceEnsureDiagnostics();

  221.     PlsrPersistenceDiagnostics.hsdValidMask =

  222.         (uint8_t)((validA != 0U ? 1U : 0U) | (validB != 0U ? 2U : 0U));

  223.     PlsrPersistenceDiagnostics.hsdGeneration[0] =

  224.         (validA != 0U) ? slotA->generation : 0UL;

  225.     PlsrPersistenceDiagnostics.hsdGeneration[1] =

  226.         (validB != 0U) ? slotB->generation : 0UL;

  227.     newestMask = PlsrPersistenceNewestMask(

  228.         validA,

  229.         validB,

  230.         PlsrPersistenceDiagnostics.hsdGeneration[0],

  231.         PlsrPersistenceDiagnostics.hsdGeneration[1]);

  232.     PlsrPersistenceDiagnostics.hsdNewestMask = newestMask;

  233.     PlsrPersistenceDiagnostics.selectedHsdCrc32 =

  234.         (newestMask == 1U) ? slotA->crc32

  235.         : (newestMask == 2U) ? slotB->crc32

  236.                              : 0UL;

  237. }

  238. 

  239. static void PlsrPersistenceUpdateSfdDiagnostics(

  240.     const volatile PLSR_SFD_FLASH_RECORD *slotA,

  241.     const volatile PLSR_SFD_FLASH_RECORD *slotB,

  242.     uint8_t validA,

  243.     uint8_t validB)

  244. {

  245.     uint8_t newestMask;

  246. 

  247.     PlsrPersistenceEnsureDiagnostics();

  248.     PlsrPersistenceDiagnostics.sfdValidMask =

  249.         (uint8_t)((validA != 0U ? 1U : 0U) | (validB != 0U ? 2U : 0U));

  250.     PlsrPersistenceDiagnostics.sfdGeneration[0] =

  251.         (validA != 0U) ? slotA->generation : 0UL;

  252.     PlsrPersistenceDiagnostics.sfdGeneration[1] =

  253.         (validB != 0U) ? slotB->generation : 0UL;

  254.     newestMask = PlsrPersistenceNewestMask(

  255.         validA,

  256.         validB,

  257.         PlsrPersistenceDiagnostics.sfdGeneration[0],

  258.         PlsrPersistenceDiagnostics.sfdGeneration[1]);

  259.     PlsrPersistenceDiagnostics.sfdNewestMask = newestMask;

  260.     PlsrPersistenceDiagnostics.selectedSfdCrc32 =

  261.         (newestMask == 1U) ? slotA->crc32

  262.         : (newestMask == 2U) ? slotB->crc32

  263.                              : 0UL;

  264. }

  265. 

  266. static void PlsrPersistenceRefreshSfdDiagnostics(void)

  267. {

  268.     volatile PLSR_SFD_FLASH_RECORD *slotA =

  269.         PlsrPersistenceGetSfdSlot(0U);

  270.     volatile PLSR_SFD_FLASH_RECORD *slotB =

  271.         PlsrPersistenceGetSfdSlot(1U);

  272. 

  273.     PlsrPersistenceUpdateSfdDiagnostics(

  274.         slotA,

  275.         slotB,

  276.         PlsrPersistenceSfdRecordIsValid(slotA),

  277.         PlsrPersistenceSfdRecordIsValid(slotB));

  278. }

  279. 

  280. static PLSR_PERSISTENCE_RESULT PlsrPersistenceCompleteSfdSave(

  281.     PLSR_PERSISTENCE_RESULT result)

  282. {

  283.     PlsrPersistenceEnsureDiagnostics();

  284.     PlsrPersistenceDiagnostics.lastSfdSaveResult = result;

  285.     PlsrPersistenceRefreshSfdDiagnostics();

  286.     if (result == PLSR_PERSISTENCE_OK)

  287.     {

  288.         PlsrPersistenceDiagnostics.sfdSaveCount++;

  289.     }

  290.     return result;

  291. }

  292. 

  293. static void PlsrPersistenceCopySfdFromVolatile(

  294.     PLSR_SFD_DATA *destination,

  295.     const volatile PLSR_SFD_DATA *source)

  296. {

  297.     uint16_t index;

  298. 

  299.     for (index = 0U; index < PLSR_SFD_CONFIG_COUNT; index++)

  300.     {

  301.         destination->config[index] = source->config[index];

  302.     }

  303. }

  304. 

  305. static void PlsrPersistenceApplyParameterSetDefaults(uint16_t *config,

  306.                                                      uint16_t base)

  307. {

  308.     /* 与信捷出厂默认一致：默认速度1000、加减速100ms、最大速度100000、

  309.      * 起始/终止速度0、FOLLOW 50、前馈0、1ms刷新。 */

  310.     config[base + 0U] = (uint16_t)(PLSR_SFD_DEFAULT_SPEED & 0xFFFFUL);

  311.     config[base + 1U] = (uint16_t)(PLSR_SFD_DEFAULT_SPEED >> 16U);

  312.     config[base + 2U] = (uint16_t)PLSR_SFD_DEFAULT_ACCEL_MS;

  313.     config[base + 3U] = (uint16_t)PLSR_SFD_DEFAULT_DECEL_MS;

  314.     config[base + 4U] = 0U;

  315.     config[base + 5U] = 0U;

  316.     config[base + 6U] = (uint16_t)(PLSR_SFD_DEFAULT_MAX_SPEED & 0xFFFFUL);

  317.     config[base + 7U] = (uint16_t)(PLSR_SFD_DEFAULT_MAX_SPEED >> 16U);

  318.     config[base + 8U] = 0U;

  319.     config[base + 9U] = 0U;

  320.     config[base + 10U] = 0U;

  321.     config[base + 11U] = 0U;

  322.     config[base + 12U] = (uint16_t)PLSR_SFD_DEFAULT_FOLLOW;

  323.     config[base + 13U] = 0U;

  324.     config[base + 14U] = 0U;

  325.     config[base + 16U] = 0U;

  326.     config[base + 17U] = 0U;

  327.     config[base + 18U] = 0U;

  328.     config[base + 19U] = 0U;

  329. }

  330. 

  331. static void PlsrPersistenceApplySfdDefaults(PLSR_SFD_DATA *data)

  332. {

  333.     uint16_t axisOffset;

  334.     uint16_t parameterOffset;

  335.     uint8_t axis;

  336.     uint8_t parameterSet;

  337. 

  338.     (void)memset(data, 0, sizeof(*data));

  339.     for (axis = 0U; axis < PLSR_AXIS_COUNT; axis++)

  340.     {

  341.         axisOffset = (uint16_t)((uint16_t)axis * PLSR_SFD_AXIS_STRIDE);

  342. 

  343.         /* 公共参数（与信捷出厂默认一致）。 */

  344.         data->config[axisOffset + 0U] = 0;              /* SFD900 方向逻辑/单位等 */

  345.         data->config[axisOffset + 1U] = 0;              /* SFD901 完成模式 */

  346.         data->config[axisOffset + 2U] = 1;              /* SFD902 脉冲数/1转=1 */

  347.         data->config[axisOffset + 3U] = 0;

  348.         data->config[axisOffset + 4U] = 1;              /* SFD904 移动量/1转=1 */

  349.         data->config[axisOffset + 5U] = 0;

  350.         data->config[axisOffset + 6U] = 0xFF;           /* SFD906 方向端子：无 */

  351.         data->config[axisOffset + 7U] = 10;             /* SFD907 方向延时10ms */

  352.         data->config[axisOffset + 8U] = 0;              /* SFD908 正向齿隙 */

  353.         data->config[axisOffset + 9U] = 0;              /* SFD909 负向齿隙 */

  354.         data->config[axisOffset + 12U] = 0;             /* SFD912 端子开关状态 */

  355.         data->config[axisOffset + 13U] = 0xFF;          /* SFD913 原点端子：无 */

  356.         data->config[axisOffset + 14U] = 0xFF;          /* SFD914 Z相端子：无 */

  357.         data->config[axisOffset + 15U] = 0xFFFF;        /* SFD915 极限端子：无 */

  358.         data->config[axisOffset + 17U] = 0xFF;          /* SFD917 CLR端子：无 */

  359.         data->config[axisOffset + 18U] = 0;             /* SFD918 VH */

  360.         data->config[axisOffset + 19U] = 0;

  361.         data->config[axisOffset + 22U] = 0;             /* SFD922 VC */

  362.         data->config[axisOffset + 23U] = 0;

  363.         data->config[axisOffset + 24U] = 0;             /* SFD924 机械原点位置 */

  364.         data->config[axisOffset + 25U] = 0;

  365.         data->config[axisOffset + 26U] = 0;             /* SFD926 Z相个数 */

  366.         data->config[axisOffset + 27U] = 20;            /* SFD927 CLR延时20ms */

  367.         data->config[axisOffset + 30U] = 0;             /* SFD930 软限位正 */

  368.         data->config[axisOffset + 31U] = 0;

  369.         data->config[axisOffset + 32U] = 0;             /* SFD932 软限位负 */

  370.         data->config[axisOffset + 33U] = 0;

  371.         data->config[axisOffset + 43U] = 0x0201;        /* SFD943 默认参数块 */

  372. 

  373.         for (parameterSet = 0U;

  374.              parameterSet < PLSR_SFD_PARAMETER_SET_COUNT;

  375.              parameterSet++)

  376.         {

  377.             parameterOffset = (uint16_t)(

  378.                 axisOffset + PLSR_SFD_PARAMETER_SET_OFFSET

  379.                 + (uint16_t)parameterSet * PLSR_SFD_PARAMETER_SET_STRIDE);

  380.             PlsrPersistenceApplyParameterSetDefaults(data->config,

  381.                                                      parameterOffset);

  382.         }

  383.     }

  384. }

  385. 

  386. static void PlsrPersistenceApplyHsdDefaults(PLSR_HSD_DATA *data)

  387. {

  388.     uint8_t axis;

  389. 

  390.     (void)memset(data, 0, sizeof(*data));

  391.     for (axis = 0U; axis < PLSR_AXIS_COUNT; axis++)

  392.     {

  393.         /* config 数组索引 = HSD地址 - PLSR_HSD_CONFIG_START。 */

  394.         PlsrPersistenceApplyParameterSetDefaults(

  395.             data->config,

  396.             (uint16_t)((uint16_t)axis * PLSR_HSD_PARAMETER_SET_STRIDE));

  397.     }

  398. }

  399. 

  400. static PLSR_PERSISTENCE_RESULT PlsrPersistenceBeginSfdOperation(void)

  401. {

  402. #ifdef PLSR_HOST_TEST

  403.     return PLSR_PERSISTENCE_OK;

  404. #else

  405.     if (HAL_FLASH_Unlock() != HAL_OK)

  406.     {

  407.         return PLSR_PERSISTENCE_PROGRAM_FAILED;

  408.     }

  409. 

  410.     __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR

  411.                            | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR

  412.                            | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);

  413.     return PLSR_PERSISTENCE_OK;

  414. #endif

  415. }

  416. 

  417. static PLSR_PERSISTENCE_RESULT PlsrPersistenceEndSfdOperation(

  418.     PLSR_PERSISTENCE_RESULT result)

  419. {

  420. #ifdef PLSR_HOST_TEST

  421.     return result;

  422. #else

  423.     if ((HAL_FLASH_Lock() != HAL_OK) && (result == PLSR_PERSISTENCE_OK))

  424.     {

  425.         return PLSR_PERSISTENCE_PROGRAM_FAILED;

  426.     }

  427.     return result;

  428. #endif

  429. }

  430. 

  431. static PLSR_PERSISTENCE_RESULT PlsrPersistenceEraseSfdSlot(uint8_t slot)

  432. {

  433. #ifdef PLSR_HOST_TEST

  434.     if (PlsrHostSfdFault == PLSR_TEST_SFD_FAULT_ERASE)

  435.     {

  436.         PlsrHostSfdFault = PLSR_TEST_SFD_FAULT_NONE;

  437.         return PLSR_PERSISTENCE_ERASE_FAILED;

  438.     }

  439.     (void)memset(&PlsrHostSfdSlots[slot],

  440.                  0xFF,

  441.                  sizeof(PlsrHostSfdSlots[slot]));

  442.     return PLSR_PERSISTENCE_OK;

  443. #else

  444.     FLASH_EraseInitTypeDef erase;

  445.     uint32_t sectorError = 0xFFFFFFFFUL;

  446. 

  447.     erase.TypeErase = FLASH_TYPEERASE_SECTORS;

  448.     erase.VoltageRange = FLASH_VOLTAGE_RANGE_3;

  449.     erase.Sector = (slot == 0U) ? FLASH_SECTOR_10 : FLASH_SECTOR_11;

  450.     erase.NbSectors = 1U;

  451. 

  452.     return (HAL_FLASHEx_Erase(&erase, &sectorError) == HAL_OK)

  453.                ? PLSR_PERSISTENCE_OK

  454.                : PLSR_PERSISTENCE_ERASE_FAILED;

  455. #endif

  456. }

  457. 

  458. static PLSR_PERSISTENCE_RESULT PlsrPersistenceProgramSfdWord(

  459.     volatile uint32_t *destination,

  460.     uint32_t value)

  461. {

  462. #ifdef PLSR_HOST_TEST

  463.     if (PlsrHostSfdFault == PLSR_TEST_SFD_FAULT_PROGRAM)

  464.     {

  465.         PlsrHostSfdFault = PLSR_TEST_SFD_FAULT_NONE;

  466.         return PLSR_PERSISTENCE_PROGRAM_FAILED;

  467.     }

  468.     if ((*destination & value) != value)

  469.     {

  470.         return PLSR_PERSISTENCE_PROGRAM_FAILED;

  471.     }

  472.     *destination &= value;

  473.     return PLSR_PERSISTENCE_OK;

  474. #else

  475.     return (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD,

  476.                               (uint32_t)destination,

  477.                               value)

  478.             == HAL_OK)

  479.                ? PLSR_PERSISTENCE_OK

  480.                : PLSR_PERSISTENCE_PROGRAM_FAILED;

  481. #endif

  482. }

  483. 

  484. static uint8_t PlsrPersistenceSfdBodyMatches(

  485.     const volatile uint32_t *destination,

  486.     const PLSR_SFD_FLASH_HEADER *header,

  487.     const PLSR_SFD_DATA *data,

  488.     uint32_t crc32)

  489. {

  490.     const uint32_t *headerWords = (const uint32_t *)header;

  491.     const uint32_t *dataWords = (const uint32_t *)data;

  492.     uint32_t headerWordCount = (uint32_t)(sizeof(*header) / sizeof(uint32_t));

  493.     uint32_t dataWordCount = (uint32_t)(sizeof(*data) / sizeof(uint32_t));

  494.     uint32_t index;

  495. 

  496.     for (index = 1U; index < headerWordCount; index++)

  497.     {

  498.         if (destination[index] != headerWords[index])

  499.         {

  500.             return 0U;

  501.         }

  502.     }

  503. 

  504.     for (index = 0U; index < dataWordCount; index++)

  505.     {

  506.         if (destination[headerWordCount + index] != dataWords[index])

  507.         {

  508.             return 0U;

  509.         }

  510.     }

  511. 

  512.     if (destination[headerWordCount + dataWordCount] != crc32)

  513.     {

  514.         return 0U;

  515.     }

  516.     return 1U;

  517. }

  518. 

  519. static void PlsrPersistenceCopyHsdFromVolatile(

  520.     PLSR_HSD_DATA *destination,

  521.     const volatile PLSR_HSD_DATA *source)

  522. {

  523.     uint16_t index;

  524. 

  525.     destination->metadata = source->metadata;

  526.     for (index = 0U; index < PLSR_HSD_RUNTIME_COUNT; index++)

  527.     {

  528.         destination->runtime[index] = source->runtime[index];

  529.     }

  530.     for (index = 0U; index < PLSR_HSD_CONFIG_COUNT; index++)

  531.     {

  532.         destination->config[index] = source->config[index];

  533.     }

  534. }

  535. 

  536. static void PlsrPersistenceWriteRecord(

  537.     volatile PLSR_HSD_BACKUP_RECORD *destination,

  538.     const PLSR_HSD_BACKUP_RECORD *source)

  539. {

  540.     const uint32_t *sourceWords = (const uint32_t *)source;

  541.     volatile uint32_t *destinationWords = (volatile uint32_t *)destination;

  542.     uint32_t wordCount = (uint32_t)(sizeof(PLSR_HSD_BACKUP_RECORD)

  543.                                     / sizeof(uint32_t));

  544.     uint32_t index;

  545. 

  546.     destination->magic = 0UL;

  547. #ifndef PLSR_HOST_TEST

  548.     __DMB();

  549. #endif

  550. 

  551.     for (index = 1U; index < wordCount; index++)

  552.     {

  553.         destinationWords[index] = sourceWords[index];

  554.     }

  555. 

  556. #ifndef PLSR_HOST_TEST

  557.     __DMB();

  558. #endif

  559.     destination->magic = PLSR_HSD_BACKUP_MAGIC;

  560. #ifndef PLSR_HOST_TEST

  561.     __DMB();

  562. #endif

  563. }

  564. 

  565. PLSR_PERSISTENCE_RESULT PlsrPersistenceLoadHsd(PLSR_HSD_DATA *data)

  566. {

  567.     volatile PLSR_HSD_BACKUP_RECORD *slotA;

  568.     volatile PLSR_HSD_BACKUP_RECORD *slotB;

  569.     const volatile PLSR_HSD_BACKUP_RECORD *selected;

  570.     uint32_t generationA;

  571.     uint32_t generationB;

  572.     uint8_t validA;

  573.     uint8_t validB;

  574. 

  575.     PlsrPersistenceEnsureDiagnostics();

  576.     if (data == NULL)

  577.     {

  578.         PlsrPersistenceDiagnostics.lastHsdLoadResult =

  579.             PLSR_PERSISTENCE_INVALID_ARGUMENT;

  580.         return PLSR_PERSISTENCE_INVALID_ARGUMENT;

  581.     }

  582. 

  583.     slotA = PlsrPersistenceGetHsdSlot(0U);

  584.     slotB = PlsrPersistenceGetHsdSlot(1U);

  585.     validA = PlsrPersistenceHsdRecordIsValid(slotA);

  586.     validB = PlsrPersistenceHsdRecordIsValid(slotB);

  587.     PlsrPersistenceUpdateHsdDiagnostics(slotA, slotB, validA, validB);

  588. 

  589.     if ((validA == 0U) && (validB == 0U))

  590.     {

  591.         PlsrPersistenceApplyHsdDefaults(data);

  592.         PlsrPersistenceDiagnostics.lastHsdLoadResult =

  593.             PLSR_PERSISTENCE_DEFAULTED;

  594.         return PLSR_PERSISTENCE_DEFAULTED;

  595.     }

  596. 

  597.     if ((validA != 0U) && (validB != 0U))

  598.     {

  599.         generationA = slotA->generation;

  600.         generationB = slotB->generation;

  601.         selected = (PlsrPersistenceGenerationIsNewer(generationB,

  602.                                                        generationA)

  603.                     != 0U)

  604.                        ? slotB

  605.                        : slotA;

  606.     }

  607.     else

  608.     {

  609.         selected = (validA != 0U) ? slotA : slotB;

  610.     }

  611. 

  612.     PlsrPersistenceCopyHsdFromVolatile(data, &selected->data);

  613.     PlsrPersistenceDiagnostics.lastHsdLoadResult = PLSR_PERSISTENCE_OK;

  614.     return PLSR_PERSISTENCE_OK;

  615. }

  616. 

  617. PLSR_PERSISTENCE_RESULT PlsrPersistenceSaveHsd(const PLSR_HSD_DATA *data)

  618. {

  619.     volatile PLSR_HSD_BACKUP_RECORD *slotA;

  620.     volatile PLSR_HSD_BACKUP_RECORD *slotB;

  621.     volatile PLSR_HSD_BACKUP_RECORD *target;

  622.     PLSR_HSD_BACKUP_RECORD record;

  623.     uint32_t newestGeneration = 0UL;

  624.     uint32_t generationA;

  625.     uint32_t generationB;

  626.     uint8_t validA;

  627.     uint8_t validB;

  628.     uint8_t targetSlot;

  629.     uint8_t targetValid;

  630. 

  631.     PlsrPersistenceEnsureDiagnostics();

  632.     if (data == NULL)

  633.     {

  634.         PlsrPersistenceDiagnostics.lastHsdSaveResult =

  635.             PLSR_PERSISTENCE_INVALID_ARGUMENT;

  636.         return PLSR_PERSISTENCE_INVALID_ARGUMENT;

  637.     }

  638. #ifdef PLSR_HOST_TEST

  639.     PlsrHostHsdSaveCount++;

  640. #endif

  641.     if (sizeof(PLSR_HSD_BACKUP_RECORD) > PLSR_BACKUP_SLOT_STRIDE)

  642.     {

  643.         PlsrPersistenceDiagnostics.lastHsdSaveResult =

  644.             PLSR_PERSISTENCE_VERIFY_FAILED;

  645.         return PLSR_PERSISTENCE_VERIFY_FAILED;

  646.     }

  647. 

  648.     slotA = PlsrPersistenceGetHsdSlot(0U);

  649.     slotB = PlsrPersistenceGetHsdSlot(1U);

  650.     validA = PlsrPersistenceHsdRecordIsValid(slotA);

  651.     validB = PlsrPersistenceHsdRecordIsValid(slotB);

  652. 

  653.     if ((validA != 0U) && (validB != 0U))

  654.     {

  655.         generationA = slotA->generation;

  656.         generationB = slotB->generation;

  657.         if (PlsrPersistenceGenerationIsNewer(generationB,

  658.                                               generationA)

  659.             != 0U)

  660.         {

  661.             newestGeneration = generationB;

  662.             target = slotA;

  663.             targetSlot = 0U;

  664.         }

  665.         else

  666.         {

  667.             newestGeneration = generationA;

  668.             target = slotB;

  669.             targetSlot = 1U;

  670.         }

  671.     }

  672.     else if (validA != 0U)

  673.     {

  674.         newestGeneration = slotA->generation;

  675.         target = slotB;

  676.         targetSlot = 1U;

  677.     }

  678.     else if (validB != 0U)

  679.     {

  680.         newestGeneration = slotB->generation;

  681.         target = slotA;

  682.         targetSlot = 0U;

  683.     }

  684.     else

  685.     {

  686.         target = slotA;

  687.         targetSlot = 0U;

  688.     }

  689. 

  690.     (void)memset(&record, 0, sizeof(record));

  691.     record.magic = PLSR_HSD_BACKUP_MAGIC;

  692.     record.version = PLSR_HSD_BACKUP_VERSION;

  693.     record.payloadLength = (uint16_t)sizeof(PLSR_HSD_DATA);

  694.     record.generation = newestGeneration + 1UL;

  695.     record.data = *data;

  696.     record.crc32 = PlsrPersistenceCrc32(

  697.         (const volatile uint8_t *)&record,

  698.         (uint32_t)offsetof(PLSR_HSD_BACKUP_RECORD, crc32));

  699. 

  700.     PlsrPersistenceWriteRecord(target, &record);

  701.     targetValid = PlsrPersistenceHsdRecordIsValid(target);

  702.     if (targetSlot == 0U)

  703.     {

  704.         validA = targetValid;

  705.     }

  706.     else

  707.     {

  708.         validB = targetValid;

  709.     }

  710.     PlsrPersistenceUpdateHsdDiagnostics(slotA, slotB, validA, validB);

  711.     PlsrPersistenceDiagnostics.lastHsdSaveResult =

  712.         (targetValid != 0U) ? PLSR_PERSISTENCE_OK

  713.                             : PLSR_PERSISTENCE_VERIFY_FAILED;

  714.     if (targetValid != 0U)

  715.     {

  716.         PlsrPersistenceDiagnostics.hsdSaveCount++;

  717.     }

  718.     return PlsrPersistenceDiagnostics.lastHsdSaveResult;

  719. }

  720. 

  721. void PlsrPersistenceResetHsd(void)

  722. {

  723.     volatile PLSR_HSD_BACKUP_RECORD *slotA =

  724.         PlsrPersistenceGetHsdSlot(0U);

  725.     volatile PLSR_HSD_BACKUP_RECORD *slotB =

  726.         PlsrPersistenceGetHsdSlot(1U);

  727. 

  728.     slotA->magic = 0UL;

  729.     slotB->magic = 0UL;

  730. #ifndef PLSR_HOST_TEST

  731.     __DMB();

  732. #endif

  733.     PlsrPersistenceUpdateHsdDiagnostics(slotA, slotB, 0U, 0U);

  734. }

  735. 

  736. PLSR_PERSISTENCE_RESULT PlsrPersistenceLoadSfd(PLSR_SFD_DATA *data)

  737. {

  738.     volatile PLSR_SFD_FLASH_RECORD *slotA;

  739.     volatile PLSR_SFD_FLASH_RECORD *slotB;

  740.     const volatile PLSR_SFD_FLASH_RECORD *selected;

  741.     uint32_t generationA;

  742.     uint32_t generationB;

  743.     uint8_t validA;

  744.     uint8_t validB;

  745. 

  746.     PlsrPersistenceEnsureDiagnostics();

  747.     if (data == NULL)

  748.     {

  749.         PlsrPersistenceDiagnostics.lastSfdLoadResult =

  750.             PLSR_PERSISTENCE_INVALID_ARGUMENT;

  751.         return PLSR_PERSISTENCE_INVALID_ARGUMENT;

  752.     }

  753. 

  754.     slotA = PlsrPersistenceGetSfdSlot(0U);

  755.     slotB = PlsrPersistenceGetSfdSlot(1U);

  756.     validA = PlsrPersistenceSfdRecordIsValid(slotA);

  757.     validB = PlsrPersistenceSfdRecordIsValid(slotB);

  758.     PlsrPersistenceUpdateSfdDiagnostics(slotA, slotB, validA, validB);

  759. 

  760.     if ((validA == 0U) && (validB == 0U))

  761.     {

  762.         PlsrPersistenceApplySfdDefaults(data);

  763.         PlsrPersistenceDiagnostics.lastSfdLoadResult =

  764.             PLSR_PERSISTENCE_DEFAULTED;

  765.         return PLSR_PERSISTENCE_DEFAULTED;

  766.     }

  767. 

  768.     if ((validA != 0U) && (validB != 0U))

  769.     {

  770.         generationA = slotA->generation;

  771.         generationB = slotB->generation;

  772.         selected = (PlsrPersistenceGenerationIsNewer(generationB,

  773.                                                        generationA)

  774.                     != 0U)

  775.                        ? slotB

  776.                        : slotA;

  777.     }

  778.     else

  779.     {

  780.         selected = (validA != 0U) ? slotA : slotB;

  781.     }

  782. 

  783.     PlsrPersistenceCopySfdFromVolatile(data, &selected->data);

  784.     PlsrPersistenceDiagnostics.lastSfdLoadResult = PLSR_PERSISTENCE_OK;

  785.     return PLSR_PERSISTENCE_OK;

  786. }

  787. 

  788. PLSR_PERSISTENCE_RESULT PlsrPersistenceSaveSfd(const PLSR_SFD_DATA *data)

  789. {

  790.     volatile PLSR_SFD_FLASH_RECORD *slotA;

  791.     volatile PLSR_SFD_FLASH_RECORD *slotB;

  792.     volatile PLSR_SFD_FLASH_RECORD *target;

  793.     volatile uint32_t *targetWords;

  794.     const uint32_t *headerWords;

  795.     const uint32_t *dataWords;

  796.     PLSR_SFD_FLASH_HEADER header;

  797.     PLSR_PERSISTENCE_RESULT result;

  798.     uint32_t newestGeneration = 0UL;

  799.     uint32_t generationA;

  800.     uint32_t generationB;

  801.     uint32_t headerWordCount;

  802.     uint32_t dataWordCount;

  803.     uint32_t crcState;

  804.     uint32_t crc32;

  805.     uint32_t index;

  806.     uint8_t targetSlot;

  807.     uint8_t validA;

  808.     uint8_t validB;

  809. 

  810.     PlsrPersistenceEnsureDiagnostics();

  811.     if (data == NULL)

  812.     {

  813.         PlsrPersistenceDiagnostics.lastSfdSaveResult =

  814.             PLSR_PERSISTENCE_INVALID_ARGUMENT;

  815.         return PLSR_PERSISTENCE_INVALID_ARGUMENT;

  816.     }

  817.     if (sizeof(PLSR_SFD_FLASH_RECORD) > PLSR_SFD_FLASH_SECTOR_SIZE)

  818.     {

  819.         PlsrPersistenceDiagnostics.lastSfdSaveResult =

  820.             PLSR_PERSISTENCE_VERIFY_FAILED;

  821.         return PLSR_PERSISTENCE_VERIFY_FAILED;

  822.     }

  823. 

  824.     slotA = PlsrPersistenceGetSfdSlot(0U);

  825.     slotB = PlsrPersistenceGetSfdSlot(1U);

  826.     validA = PlsrPersistenceSfdRecordIsValid(slotA);

  827.     validB = PlsrPersistenceSfdRecordIsValid(slotB);

  828. 

  829.     if ((validA != 0U) && (validB != 0U))

  830.     {

  831.         generationA = slotA->generation;

  832.         generationB = slotB->generation;

  833.         if (PlsrPersistenceGenerationIsNewer(generationB,

  834.                                              generationA)

  835.             != 0U)

  836.         {

  837.             newestGeneration = generationB;

  838.             target = slotA;

  839.             targetSlot = 0U;

  840.         }

  841.         else

  842.         {

  843.             newestGeneration = generationA;

  844.             target = slotB;

  845.             targetSlot = 1U;

  846.         }

  847.     }

  848.     else if (validA != 0U)

  849.     {

  850.         newestGeneration = slotA->generation;

  851.         target = slotB;

  852.         targetSlot = 1U;

  853.     }

  854.     else if (validB != 0U)

  855.     {

  856.         newestGeneration = slotB->generation;

  857.         target = slotA;

  858.         targetSlot = 0U;

  859.     }

  860.     else

  861.     {

  862.         target = slotA;

  863.         targetSlot = 0U;

  864.     }

  865. 

  866.     header.magic = PLSR_SFD_FLASH_MAGIC;

  867.     header.version = PLSR_SFD_FLASH_VERSION;

  868.     header.payloadLength = (uint16_t)sizeof(PLSR_SFD_DATA);

  869.     header.generation = newestGeneration + 1UL;

  870.     crcState = PlsrPersistenceCrc32Update(

  871.         0xFFFFFFFFUL,

  872.         (const volatile uint8_t *)&header,

  873.         (uint32_t)sizeof(header));

  874.     crcState = PlsrPersistenceCrc32Update(

  875.         crcState,

  876.         (const volatile uint8_t *)data,

  877.         (uint32_t)sizeof(*data));

  878.     crc32 = ~crcState;

  879. 

  880.     headerWordCount = (uint32_t)(sizeof(header) / sizeof(uint32_t));

  881.     dataWordCount = (uint32_t)(sizeof(*data) / sizeof(uint32_t));

  882.     headerWords = (const uint32_t *)&header;

  883.     dataWords = (const uint32_t *)data;

  884.     targetWords = (volatile uint32_t *)target;

  885. 

  886.     result = PlsrPersistenceBeginSfdOperation();

  887.     if (result != PLSR_PERSISTENCE_OK)

  888.     {

  889.         return PlsrPersistenceCompleteSfdSave(result);

  890.     }

  891. 

  892.     result = PlsrPersistenceEraseSfdSlot(targetSlot);

  893.     if (result != PLSR_PERSISTENCE_OK)

  894.     {

  895.         result = PlsrPersistenceEndSfdOperation(result);

  896.         return PlsrPersistenceCompleteSfdSave(result);

  897.     }

  898. 

  899.     /* The valid magic is committed last so an interrupted write stays invalid. */

  900.     for (index = 1U; index < headerWordCount; index++)

  901.     {

  902.         result = PlsrPersistenceProgramSfdWord(&targetWords[index],

  903.                                                headerWords[index]);

  904.         if (result != PLSR_PERSISTENCE_OK)

  905.         {

  906.             result = PlsrPersistenceEndSfdOperation(result);

  907.             return PlsrPersistenceCompleteSfdSave(result);

  908.         }

  909.     }

  910. 

  911.     for (index = 0U; index < dataWordCount; index++)

  912.     {

  913.         result = PlsrPersistenceProgramSfdWord(

  914.             &targetWords[headerWordCount + index],

  915.             dataWords[index]);

  916.         if (result != PLSR_PERSISTENCE_OK)

  917.         {

  918.             result = PlsrPersistenceEndSfdOperation(result);

  919.             return PlsrPersistenceCompleteSfdSave(result);

  920.         }

  921.     }

  922. 

  923.     result = PlsrPersistenceProgramSfdWord(

  924.         &targetWords[headerWordCount + dataWordCount],

  925.         crc32);

  926.     if (result != PLSR_PERSISTENCE_OK)

  927.     {

  928.         result = PlsrPersistenceEndSfdOperation(result);

  929.         return PlsrPersistenceCompleteSfdSave(result);

  930.     }

  931. 

  932. #ifdef PLSR_HOST_TEST

  933.     if (PlsrHostSfdFault == PLSR_TEST_SFD_FAULT_VERIFY)

  934.     {

  935.         targetWords[1] ^= 1UL;

  936.         PlsrHostSfdFault = PLSR_TEST_SFD_FAULT_NONE;

  937.     }

  938. #endif

  939.     if (PlsrPersistenceSfdBodyMatches(targetWords,

  940.                                       &header,

  941.                                       data,

  942.                                       crc32)

  943.         == 0U)

  944.     {

  945.         result = PlsrPersistenceEndSfdOperation(

  946.             PLSR_PERSISTENCE_VERIFY_FAILED);

  947.         return PlsrPersistenceCompleteSfdSave(result);

  948.     }

  949. 

  950. #ifdef PLSR_HOST_TEST

  951.     if (PlsrHostSfdFault == PLSR_TEST_SFD_FAULT_BEFORE_COMMIT)

  952.     {

  953.         PlsrHostSfdFault = PLSR_TEST_SFD_FAULT_NONE;

  954.         result = PlsrPersistenceEndSfdOperation(

  955.             PLSR_PERSISTENCE_PROGRAM_FAILED);

  956.         return PlsrPersistenceCompleteSfdSave(result);

  957.     }

  958. #endif

  959. 

  960.     result = PlsrPersistenceProgramSfdWord(&targetWords[0], headerWords[0]);

  961.     if (result != PLSR_PERSISTENCE_OK)

  962.     {

  963.         result = PlsrPersistenceEndSfdOperation(result);

  964.         return PlsrPersistenceCompleteSfdSave(result);

  965.     }

  966. 

  967.     result = (PlsrPersistenceSfdRecordIsValid(target) != 0U)

  968.                  ? PLSR_PERSISTENCE_OK

  969.                  : PLSR_PERSISTENCE_VERIFY_FAILED;

  970.     result = PlsrPersistenceEndSfdOperation(result);

  971.     return PlsrPersistenceCompleteSfdSave(result);

  972. }

  973. 

  974. PLSR_PERSISTENCE_RESULT PlsrPersistenceEraseSfd(void)

  975. {

  976.     PLSR_PERSISTENCE_RESULT result;

  977. 

  978.     PlsrPersistenceEnsureDiagnostics();

  979.     result = PlsrPersistenceBeginSfdOperation();

  980.     if (result != PLSR_PERSISTENCE_OK)

  981.     {

  982.         PlsrPersistenceDiagnostics.lastSfdEraseResult = result;

  983.         return result;

  984.     }

  985. 

  986.     result = PlsrPersistenceEraseSfdSlot(0U);

  987.     if (result == PLSR_PERSISTENCE_OK)

  988.     {

  989.         result = PlsrPersistenceEraseSfdSlot(1U);

  990.     }

  991. 

  992.     result = PlsrPersistenceEndSfdOperation(result);

  993.     PlsrPersistenceDiagnostics.lastSfdEraseResult = result;

  994.     PlsrPersistenceRefreshSfdDiagnostics();

  995.     return result;

  996. }

  997. 

  998. void PlsrPersistenceGetDiagnostics(

  999.     PLSR_PERSISTENCE_DIAGNOSTICS *diagnostics)

  1000. {

  1001.     if (diagnostics == NULL)

  1002.     {

  1003.         return;

  1004.     }

  1005.     PlsrPersistenceEnsureDiagnostics();

  1006.     *diagnostics = PlsrPersistenceDiagnostics;

  1007. }

  1008. 

  1009. PLSR_PERSISTENCE_RESULT PlsrPersistenceDiagnosticInvalidateNewest(

  1010.     PLSR_PERSISTENCE_DIAG_TARGET target)

  1011. {

  1012. #if PLSR_ENABLE_DESTRUCTIVE_PERSISTENCE_DIAG != 0U

  1013.     uint32_t generationA;

  1014.     uint32_t generationB;

  1015.     uint8_t validA;

  1016.     uint8_t validB;

  1017. 

  1018.     PlsrPersistenceEnsureDiagnostics();

  1019.     if (target == PLSR_PERSISTENCE_DIAG_TARGET_HSD)

  1020.     {

  1021.         volatile PLSR_HSD_BACKUP_RECORD *slotA =

  1022.             PlsrPersistenceGetHsdSlot(0U);

  1023.         volatile PLSR_HSD_BACKUP_RECORD *slotB =

  1024.             PlsrPersistenceGetHsdSlot(1U);

  1025.         volatile PLSR_HSD_BACKUP_RECORD *newest;

  1026. 

  1027.         validA = PlsrPersistenceHsdRecordIsValid(slotA);

  1028.         validB = PlsrPersistenceHsdRecordIsValid(slotB);

  1029.         PlsrPersistenceUpdateHsdDiagnostics(slotA, slotB, validA, validB);

  1030.         if ((validA == 0U) || (validB == 0U))

  1031.         {

  1032.             return PLSR_PERSISTENCE_VERIFY_FAILED;

  1033.         }

  1034.         generationA = slotA->generation;

  1035.         generationB = slotB->generation;

  1036.         newest = (PlsrPersistenceGenerationIsNewer(generationB, generationA)

  1037.                   != 0U)

  1038.                      ? slotB

  1039.                      : slotA;

  1040.         newest->magic = 0UL;

  1041. #ifndef PLSR_HOST_TEST

  1042.         __DMB();

  1043. #endif

  1044.         PlsrPersistenceUpdateHsdDiagnostics(

  1045.             slotA,

  1046.             slotB,

  1047.             (newest == slotA) ? 0U : 1U,

  1048.             (newest == slotB) ? 0U : 1U);

  1049.         return PLSR_PERSISTENCE_OK;

  1050.     }

  1051.     if (target == PLSR_PERSISTENCE_DIAG_TARGET_SFD)

  1052.     {

  1053.         volatile PLSR_SFD_FLASH_RECORD *slotA =

  1054.             PlsrPersistenceGetSfdSlot(0U);

  1055.         volatile PLSR_SFD_FLASH_RECORD *slotB =

  1056.             PlsrPersistenceGetSfdSlot(1U);

  1057.         volatile PLSR_SFD_FLASH_RECORD *newest;

  1058.         PLSR_PERSISTENCE_RESULT result;

  1059. 

  1060.         validA = PlsrPersistenceSfdRecordIsValid(slotA);

  1061.         validB = PlsrPersistenceSfdRecordIsValid(slotB);

  1062.         PlsrPersistenceUpdateSfdDiagnostics(slotA, slotB, validA, validB);

  1063.         if ((validA == 0U) || (validB == 0U))

  1064.         {

  1065.             return PLSR_PERSISTENCE_VERIFY_FAILED;

  1066.         }

  1067.         generationA = slotA->generation;

  1068.         generationB = slotB->generation;

  1069.         newest = (PlsrPersistenceGenerationIsNewer(generationB, generationA)

  1070.                   != 0U)

  1071.                      ? slotB

  1072.                      : slotA;

  1073.         result = PlsrPersistenceBeginSfdOperation();

  1074.         if (result == PLSR_PERSISTENCE_OK)

  1075.         {

  1076.             result = PlsrPersistenceProgramSfdWord(

  1077.                 (volatile uint32_t *)&newest->magic,

  1078.                 0UL);

  1079.             result = PlsrPersistenceEndSfdOperation(result);

  1080.         }

  1081.         PlsrPersistenceRefreshSfdDiagnostics();

  1082.         return result;

  1083.     }

  1084.     return PLSR_PERSISTENCE_INVALID_ARGUMENT;

  1085. #else

  1086.     (void)target;

  1087.     return PLSR_PERSISTENCE_NOT_IMPLEMENTED;

  1088. #endif

  1089. }

  1090. 

  1091. #ifdef PLSR_HOST_TEST

  1092. void PlsrPersistenceTestResetStorage(void)

  1093. {

  1094.     (void)memset(PlsrHostBackupSlots, 0, sizeof(PlsrHostBackupSlots));

  1095.     (void)memset(PlsrHostSfdSlots, 0xFF, sizeof(PlsrHostSfdSlots));

  1096.     PlsrHostSfdFault = PLSR_TEST_SFD_FAULT_NONE;

  1097.     PlsrHostHsdSaveCount = 0UL;

  1098.     PlsrPersistenceDiagnosticsInitialized = 0U;

  1099.     PlsrPersistenceEnsureDiagnostics();

  1100.     PlsrPersistenceUpdateHsdDiagnostics(

  1101.         PlsrPersistenceGetHsdSlot(0U),

  1102.         PlsrPersistenceGetHsdSlot(1U),

  1103.         0U,

  1104.         0U);

  1105.     PlsrPersistenceRefreshSfdDiagnostics();

  1106. }

  1107. 

  1108. uint32_t PlsrPersistenceTestGetHsdSaveCount(void)

  1109. {

  1110.     return PlsrHostHsdSaveCount;

  1111. }

  1112. 

  1113. uint32_t PlsrPersistenceTestCrc32(const uint8_t *data, uint32_t length)

  1114. {

  1115.     if ((data == NULL) && (length != 0UL))

  1116.     {

  1117.         return 0UL;

  1118.     }

  1119.     return PlsrPersistenceCrc32(data, length);

  1120. }

  1121. 

  1122. void PlsrPersistenceTestCorruptNewestHsd(void)

  1123. {

  1124.     volatile PLSR_HSD_BACKUP_RECORD *slotA = PlsrPersistenceGetHsdSlot(0U);

  1125.     volatile PLSR_HSD_BACKUP_RECORD *slotB = PlsrPersistenceGetHsdSlot(1U);

  1126.     uint8_t validA = PlsrPersistenceHsdRecordIsValid(slotA);

  1127.     uint8_t validB = PlsrPersistenceHsdRecordIsValid(slotB);

  1128.     volatile PLSR_HSD_BACKUP_RECORD *newest;

  1129. 

  1130.     if ((validA == 0U) && (validB == 0U))

  1131.     {

  1132.         return;

  1133.     }

  1134.     if ((validA != 0U) && (validB != 0U))

  1135.     {

  1136.         newest = (PlsrPersistenceGenerationIsNewer(slotB->generation,

  1137.                                                     slotA->generation)

  1138.                   != 0U)

  1139.                      ? slotB

  1140.                      : slotA;

  1141.     }

  1142.     else

  1143.     {

  1144.         newest = (validA != 0U) ? slotA : slotB;

  1145.     }

  1146. 

  1147.     newest->crc32 ^= 1UL;

  1148. }

  1149. 

  1150. void PlsrPersistenceTestCorruptNewestSfd(void)

  1151. {

  1152.     volatile PLSR_SFD_FLASH_RECORD *slotA = PlsrPersistenceGetSfdSlot(0U);

  1153.     volatile PLSR_SFD_FLASH_RECORD *slotB = PlsrPersistenceGetSfdSlot(1U);

  1154.     uint8_t validA = PlsrPersistenceSfdRecordIsValid(slotA);

  1155.     uint8_t validB = PlsrPersistenceSfdRecordIsValid(slotB);

  1156.     volatile PLSR_SFD_FLASH_RECORD *newest;

  1157. 

  1158.     if ((validA == 0U) && (validB == 0U))

  1159.     {

  1160.         return;

  1161.     }

  1162.     if ((validA != 0U) && (validB != 0U))

  1163.     {

  1164.         newest = (PlsrPersistenceGenerationIsNewer(slotB->generation,

  1165.                                                     slotA->generation)

  1166.                   != 0U)

  1167.                      ? slotB

  1168.                      : slotA;

  1169.     }

  1170.     else

  1171.     {

  1172.         newest = (validA != 0U) ? slotA : slotB;

  1173.     }

  1174. 

  1175.     newest->crc32 ^= 1UL;

  1176. }

  1177. 

  1178. void PlsrPersistenceTestSetSfdFault(PLSR_TEST_SFD_FAULT fault)

  1179. {

  1180.     PlsrHostSfdFault = fault;

  1181. }

  1182. #endif