yuwenhao
/
Modbus-rtu
1
0
複製 0
程式碼 問題 0 合併請求 0 版本發佈 0 Wiki 活動
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
32 提交
3 分支
138 MiB
 
 
 
 
 
 
目錄樹: 83803085ec
分支列表 標籤
${ item.name }
建立分支 ${ searchTerm }
從 '83803085ec'
${ noResults }
Modbus-rtu/PLSR/Src/plsr_persistence.c

870 line
25 KiB
原始文件 Blame 歷史記錄 

  1. #include "plsr_persistence.h"

  2. #include <stddef.h>

  3. #include <string.h>

  4. 

  5. #define PLSR_HSD_BACKUP_MAGIC          (0x504C4853UL)

  6. #define PLSR_HSD_BACKUP_VERSION        (2U)

  7. #define PLSR_BACKUP_SLOT_A_OFFSET      (0x0100UL)

  8. #define PLSR_BACKUP_SLOT_STRIDE        (0x0200UL)

  9. #define PLSR_SFD_FLASH_MAGIC           (0x504C5346UL)

  10. #define PLSR_SFD_FLASH_VERSION         (1U)

  11. #define PLSR_SFD_FLASH_SLOT_A_ADDRESS  (0x080C0000UL)

  12. #define PLSR_SFD_FLASH_SLOT_B_ADDRESS  (0x080E0000UL)

  13. #define PLSR_SFD_FLASH_SECTOR_SIZE     (0x00020000UL)

  14. #define PLSR_SFD_AXIS_STRIDE           (130U)

  15. #define PLSR_SFD_PARAMETER_SET_COUNT   (4U)

  16. #define PLSR_SFD_PARAMETER_SET_OFFSET  (50U)

  17. #define PLSR_SFD_PARAMETER_SET_STRIDE  (20U)

  18. #define PLSR_SFD_DEFAULT_MAX_SPEED     (100000UL)

  19. #define PLSR_SFD_DEFAULT_SPEED         (1000UL)

  20. #define PLSR_SFD_DEFAULT_ACCEL_MS      (100U)

  21. #define PLSR_SFD_DEFAULT_DECEL_MS      (100U)

  22. #define PLSR_SFD_DEFAULT_FOLLOW        (50U)

  23. #define PLSR_HSD_PARAMETER_SET_STRIDE  (20U)

  24. #define PLSR_HSD_DEFAULT_BASE          (460U)

  25. 

  26. typedef struct

  27. {

  28.     uint32_t magic;

  29.     uint16_t version;

  30.     uint16_t payloadLength;

  31.     uint32_t generation;

  32.     PLSR_HSD_DATA data;

  33.     uint32_t crc32;

  34. } PLSR_HSD_BACKUP_RECORD;

  35. 

  36. typedef struct

  37. {

  38.     uint32_t magic;

  39.     uint16_t version;

  40.     uint16_t payloadLength;

  41.     uint32_t generation;

  42. } PLSR_SFD_FLASH_HEADER;

  43. 

  44. typedef struct

  45. {

  46.     uint32_t magic;

  47.     uint16_t version;

  48.     uint16_t payloadLength;

  49.     uint32_t generation;

  50.     PLSR_SFD_DATA data;

  51.     uint32_t crc32;

  52. } PLSR_SFD_FLASH_RECORD;

  53. 

  54. #ifdef PLSR_HOST_TEST

  55. static PLSR_HSD_BACKUP_RECORD PlsrHostBackupSlots[2];

  56. static PLSR_SFD_FLASH_RECORD PlsrHostSfdSlots[2];

  57. static PLSR_TEST_SFD_FAULT PlsrHostSfdFault;

  58. #else

  59. #include "stm32f4xx.h"

  60. #include "stm32f4xx_hal.h"

  61. #include "stm32f4xx_hal_flash_ex.h"

  62. #endif

  63. 

  64. static uint32_t PlsrPersistenceCrc32Update(uint32_t crc,

  65.                                           const volatile uint8_t *data,

  66.                                           uint32_t length)

  67. {

  68.     uint32_t index;

  69.     uint8_t bit;

  70. 

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

  72.     {

  73.         crc ^= data[index];

  74.         for (bit = 0U; bit < 8U; bit++)

  75.         {

  76.             if ((crc & 1UL) != 0UL)

  77.             {

  78.                 crc = (crc >> 1U) ^ 0xEDB88320UL;

  79.             }

  80.             else

  81.             {

  82.                 crc >>= 1U;

  83.             }

  84.         }

  85.     }

  86. 

  87.     return crc;

  88. }

  89. 

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

  91.                                     uint32_t length)

  92. {

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

  94. }

  95. 

  96. static volatile PLSR_HSD_BACKUP_RECORD *PlsrPersistenceGetHsdSlot(

  97.     uint8_t slot)

  98. {

  99. #ifdef PLSR_HOST_TEST

  100.     return &PlsrHostBackupSlots[slot];

  101. #else

  102.     uint32_t offset = PLSR_BACKUP_SLOT_A_OFFSET

  103.                       + (uint32_t)slot * PLSR_BACKUP_SLOT_STRIDE;

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

  105. #endif

  106. }

  107. 

  108. static uint8_t PlsrPersistenceHsdRecordIsValid(

  109.     const volatile PLSR_HSD_BACKUP_RECORD *record)

  110. {

  111.     uint32_t expectedCrc;

  112. 

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

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

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

  116.     {

  117.         return 0U;

  118.     }

  119. 

  120.     expectedCrc = PlsrPersistenceCrc32(

  121.         (const volatile uint8_t *)record,

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

  123. 

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

  125. }

  126. 

  127. static uint8_t PlsrPersistenceGenerationIsNewer(uint32_t left,

  128.                                                 uint32_t right)

  129. {

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

  131. }

  132. 

  133. static volatile PLSR_SFD_FLASH_RECORD *PlsrPersistenceGetSfdSlot(

  134.     uint8_t slot)

  135. {

  136. #ifdef PLSR_HOST_TEST

  137.     return &PlsrHostSfdSlots[slot];

  138. #else

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

  140.                                     : PLSR_SFD_FLASH_SLOT_B_ADDRESS;

  141.     return (volatile PLSR_SFD_FLASH_RECORD *)address;

  142. #endif

  143. }

  144. 

  145. static uint8_t PlsrPersistenceSfdRecordIsValid(

  146.     const volatile PLSR_SFD_FLASH_RECORD *record)

  147. {

  148.     uint32_t expectedCrc;

  149. 

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

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

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

  153.     {

  154.         return 0U;

  155.     }

  156. 

  157.     expectedCrc = PlsrPersistenceCrc32(

  158.         (const volatile uint8_t *)record,

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

  160. 

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

  162. }

  163. 

  164. static void PlsrPersistenceCopySfdFromVolatile(

  165.     PLSR_SFD_DATA *destination,

  166.     const volatile PLSR_SFD_DATA *source)

  167. {

  168.     uint16_t index;

  169. 

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

  171.     {

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

  173.     }

  174. }

  175. 

  176. static void PlsrPersistenceApplyParameterSetDefaults(uint16_t *config,

  177.                                                      uint16_t base)

  178. {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  200. }

  201. 

  202. static void PlsrPersistenceApplySfdDefaults(PLSR_SFD_DATA *data)

  203. {

  204.     uint16_t axisOffset;

  205.     uint16_t parameterOffset;

  206.     uint8_t axis;

  207.     uint8_t parameterSet;

  208. 

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

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

  211.     {

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

  213. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  243. 

  244.         for (parameterSet = 0U;

  245.              parameterSet < PLSR_SFD_PARAMETER_SET_COUNT;

  246.              parameterSet++)

  247.         {

  248.             parameterOffset = (uint16_t)(

  249.                 axisOffset + PLSR_SFD_PARAMETER_SET_OFFSET

  250.                 + (uint16_t)parameterSet * PLSR_SFD_PARAMETER_SET_STRIDE);

  251.             PlsrPersistenceApplyParameterSetDefaults(data->config,

  252.                                                      parameterOffset);

  253.         }

  254.     }

  255. }

  256. 

  257. static void PlsrPersistenceApplyHsdDefaults(PLSR_HSD_DATA *data)

  258. {

  259.     uint8_t axis;

  260. 

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

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

  263.     {

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

  265.         PlsrPersistenceApplyParameterSetDefaults(

  266.             data->config,

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

  268.     }

  269. }

  270. 

  271. static PLSR_PERSISTENCE_RESULT PlsrPersistenceBeginSfdOperation(void)

  272. {

  273. #ifdef PLSR_HOST_TEST

  274.     return PLSR_PERSISTENCE_OK;

  275. #else

  276.     if (HAL_FLASH_Unlock() != HAL_OK)

  277.     {

  278.         return PLSR_PERSISTENCE_PROGRAM_FAILED;

  279.     }

  280. 

  281.     __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR

  282.                            | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR

  283.                            | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);

  284.     return PLSR_PERSISTENCE_OK;

  285. #endif

  286. }

  287. 

  288. static PLSR_PERSISTENCE_RESULT PlsrPersistenceEndSfdOperation(

  289.     PLSR_PERSISTENCE_RESULT result)

  290. {

  291. #ifdef PLSR_HOST_TEST

  292.     return result;

  293. #else

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

  295.     {

  296.         return PLSR_PERSISTENCE_PROGRAM_FAILED;

  297.     }

  298.     return result;

  299. #endif

  300. }

  301. 

  302. static PLSR_PERSISTENCE_RESULT PlsrPersistenceEraseSfdSlot(uint8_t slot)

  303. {

  304. #ifdef PLSR_HOST_TEST

  305.     if (PlsrHostSfdFault == PLSR_TEST_SFD_FAULT_ERASE)

  306.     {

  307.         PlsrHostSfdFault = PLSR_TEST_SFD_FAULT_NONE;

  308.         return PLSR_PERSISTENCE_ERASE_FAILED;

  309.     }

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

  311.                  0xFF,

  312.                  sizeof(PlsrHostSfdSlots[slot]));

  313.     return PLSR_PERSISTENCE_OK;

  314. #else

  315.     FLASH_EraseInitTypeDef erase;

  316.     uint32_t sectorError = 0xFFFFFFFFUL;

  317. 

  318.     erase.TypeErase = FLASH_TYPEERASE_SECTORS;

  319.     erase.VoltageRange = FLASH_VOLTAGE_RANGE_3;

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

  321.     erase.NbSectors = 1U;

  322. 

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

  324.                ? PLSR_PERSISTENCE_OK

  325.                : PLSR_PERSISTENCE_ERASE_FAILED;

  326. #endif

  327. }

  328. 

  329. static PLSR_PERSISTENCE_RESULT PlsrPersistenceProgramSfdWord(

  330.     volatile uint32_t *destination,

  331.     uint32_t value)

  332. {

  333. #ifdef PLSR_HOST_TEST

  334.     if (PlsrHostSfdFault == PLSR_TEST_SFD_FAULT_PROGRAM)

  335.     {

  336.         PlsrHostSfdFault = PLSR_TEST_SFD_FAULT_NONE;

  337.         return PLSR_PERSISTENCE_PROGRAM_FAILED;

  338.     }

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

  340.     {

  341.         return PLSR_PERSISTENCE_PROGRAM_FAILED;

  342.     }

  343.     *destination &= value;

  344.     return PLSR_PERSISTENCE_OK;

  345. #else

  346.     return (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD,

  347.                               (uint32_t)destination,

  348.                               value)

  349.             == HAL_OK)

  350.                ? PLSR_PERSISTENCE_OK

  351.                : PLSR_PERSISTENCE_PROGRAM_FAILED;

  352. #endif

  353. }

  354. 

  355. static uint8_t PlsrPersistenceSfdBodyMatches(

  356.     const volatile uint32_t *destination,

  357.     const PLSR_SFD_FLASH_HEADER *header,

  358.     const PLSR_SFD_DATA *data,

  359.     uint32_t crc32)

  360. {

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

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

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

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

  365.     uint32_t index;

  366. 

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

  368.     {

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

  370.         {

  371.             return 0U;

  372.         }

  373.     }

  374. 

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

  376.     {

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

  378.         {

  379.             return 0U;

  380.         }

  381.     }

  382. 

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

  384.     {

  385.         return 0U;

  386.     }

  387.     return 1U;

  388. }

  389. 

  390. static void PlsrPersistenceCopyHsdFromVolatile(

  391.     PLSR_HSD_DATA *destination,

  392.     const volatile PLSR_HSD_DATA *source)

  393. {

  394.     uint16_t index;

  395. 

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

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

  398.     {

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

  400.     }

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

  402.     {

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

  404.     }

  405. }

  406. 

  407. static void PlsrPersistenceWriteRecord(

  408.     volatile PLSR_HSD_BACKUP_RECORD *destination,

  409.     const PLSR_HSD_BACKUP_RECORD *source)

  410. {

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

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

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

  414.                                     / sizeof(uint32_t));

  415.     uint32_t index;

  416. 

  417.     destination->magic = 0UL;

  418. #ifndef PLSR_HOST_TEST

  419.     __DMB();

  420. #endif

  421. 

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

  423.     {

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

  425.     }

  426. 

  427. #ifndef PLSR_HOST_TEST

  428.     __DMB();

  429. #endif

  430.     destination->magic = PLSR_HSD_BACKUP_MAGIC;

  431. #ifndef PLSR_HOST_TEST

  432.     __DMB();

  433. #endif

  434. }

  435. 

  436. PLSR_PERSISTENCE_RESULT PlsrPersistenceLoadHsd(PLSR_HSD_DATA *data)

  437. {

  438.     volatile PLSR_HSD_BACKUP_RECORD *slotA;

  439.     volatile PLSR_HSD_BACKUP_RECORD *slotB;

  440.     const volatile PLSR_HSD_BACKUP_RECORD *selected;

  441.     uint32_t generationA;

  442.     uint32_t generationB;

  443.     uint8_t validA;

  444.     uint8_t validB;

  445. 

  446.     if (data == NULL)

  447.     {

  448.         return PLSR_PERSISTENCE_INVALID_ARGUMENT;

  449.     }

  450. 

  451.     slotA = PlsrPersistenceGetHsdSlot(0U);

  452.     slotB = PlsrPersistenceGetHsdSlot(1U);

  453.     validA = PlsrPersistenceHsdRecordIsValid(slotA);

  454.     validB = PlsrPersistenceHsdRecordIsValid(slotB);

  455. 

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

  457.     {

  458.         PlsrPersistenceApplyHsdDefaults(data);

  459.         return PLSR_PERSISTENCE_DEFAULTED;

  460.     }

  461. 

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

  463.     {

  464.         generationA = slotA->generation;

  465.         generationB = slotB->generation;

  466.         selected = (PlsrPersistenceGenerationIsNewer(generationB,

  467.                                                        generationA)

  468.                     != 0U)

  469.                        ? slotB

  470.                        : slotA;

  471.     }

  472.     else

  473.     {

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

  475.     }

  476. 

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

  478.     return PLSR_PERSISTENCE_OK;

  479. }

  480. 

  481. PLSR_PERSISTENCE_RESULT PlsrPersistenceSaveHsd(const PLSR_HSD_DATA *data)

  482. {

  483.     volatile PLSR_HSD_BACKUP_RECORD *slotA;

  484.     volatile PLSR_HSD_BACKUP_RECORD *slotB;

  485.     volatile PLSR_HSD_BACKUP_RECORD *target;

  486.     PLSR_HSD_BACKUP_RECORD record;

  487.     uint32_t newestGeneration = 0UL;

  488.     uint32_t generationA;

  489.     uint32_t generationB;

  490.     uint8_t validA;

  491.     uint8_t validB;

  492. 

  493.     if (data == NULL)

  494.     {

  495.         return PLSR_PERSISTENCE_INVALID_ARGUMENT;

  496.     }

  497.     if (sizeof(PLSR_HSD_BACKUP_RECORD) > PLSR_BACKUP_SLOT_STRIDE)

  498.     {

  499.         return PLSR_PERSISTENCE_VERIFY_FAILED;

  500.     }

  501. 

  502.     slotA = PlsrPersistenceGetHsdSlot(0U);

  503.     slotB = PlsrPersistenceGetHsdSlot(1U);

  504.     validA = PlsrPersistenceHsdRecordIsValid(slotA);

  505.     validB = PlsrPersistenceHsdRecordIsValid(slotB);

  506. 

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

  508.     {

  509.         generationA = slotA->generation;

  510.         generationB = slotB->generation;

  511.         if (PlsrPersistenceGenerationIsNewer(generationB,

  512.                                               generationA)

  513.             != 0U)

  514.         {

  515.             newestGeneration = generationB;

  516.             target = slotA;

  517.         }

  518.         else

  519.         {

  520.             newestGeneration = generationA;

  521.             target = slotB;

  522.         }

  523.     }

  524.     else if (validA != 0U)

  525.     {

  526.         newestGeneration = slotA->generation;

  527.         target = slotB;

  528.     }

  529.     else if (validB != 0U)

  530.     {

  531.         newestGeneration = slotB->generation;

  532.         target = slotA;

  533.     }

  534.     else

  535.     {

  536.         target = slotA;

  537.     }

  538. 

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

  540.     record.magic = PLSR_HSD_BACKUP_MAGIC;

  541.     record.version = PLSR_HSD_BACKUP_VERSION;

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

  543.     record.generation = newestGeneration + 1UL;

  544.     record.data = *data;

  545.     record.crc32 = PlsrPersistenceCrc32(

  546.         (const volatile uint8_t *)&record,

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

  548. 

  549.     PlsrPersistenceWriteRecord(target, &record);

  550.     return (PlsrPersistenceHsdRecordIsValid(target) != 0U)

  551.                ? PLSR_PERSISTENCE_OK

  552.                : PLSR_PERSISTENCE_VERIFY_FAILED;

  553. }

  554. 

  555. void PlsrPersistenceResetHsd(void)

  556. {

  557.     PlsrPersistenceGetHsdSlot(0U)->magic = 0UL;

  558.     PlsrPersistenceGetHsdSlot(1U)->magic = 0UL;

  559. #ifndef PLSR_HOST_TEST

  560.     __DMB();

  561. #endif

  562. }

  563. 

  564. PLSR_PERSISTENCE_RESULT PlsrPersistenceLoadSfd(PLSR_SFD_DATA *data)

  565. {

  566.     volatile PLSR_SFD_FLASH_RECORD *slotA;

  567.     volatile PLSR_SFD_FLASH_RECORD *slotB;

  568.     const volatile PLSR_SFD_FLASH_RECORD *selected;

  569.     uint32_t generationA;

  570.     uint32_t generationB;

  571.     uint8_t validA;

  572.     uint8_t validB;

  573. 

  574.     if (data == NULL)

  575.     {

  576.         return PLSR_PERSISTENCE_INVALID_ARGUMENT;

  577.     }

  578. 

  579.     slotA = PlsrPersistenceGetSfdSlot(0U);

  580.     slotB = PlsrPersistenceGetSfdSlot(1U);

  581.     validA = PlsrPersistenceSfdRecordIsValid(slotA);

  582.     validB = PlsrPersistenceSfdRecordIsValid(slotB);

  583. 

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

  585.     {

  586.         PlsrPersistenceApplySfdDefaults(data);

  587.         return PLSR_PERSISTENCE_DEFAULTED;

  588.     }

  589. 

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

  591.     {

  592.         generationA = slotA->generation;

  593.         generationB = slotB->generation;

  594.         selected = (PlsrPersistenceGenerationIsNewer(generationB,

  595.                                                        generationA)

  596.                     != 0U)

  597.                        ? slotB

  598.                        : slotA;

  599.     }

  600.     else

  601.     {

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

  603.     }

  604. 

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

  606.     return PLSR_PERSISTENCE_OK;

  607. }

  608. 

  609. PLSR_PERSISTENCE_RESULT PlsrPersistenceSaveSfd(const PLSR_SFD_DATA *data)

  610. {

  611.     volatile PLSR_SFD_FLASH_RECORD *slotA;

  612.     volatile PLSR_SFD_FLASH_RECORD *slotB;

  613.     volatile PLSR_SFD_FLASH_RECORD *target;

  614.     volatile uint32_t *targetWords;

  615.     const uint32_t *headerWords;

  616.     const uint32_t *dataWords;

  617.     PLSR_SFD_FLASH_HEADER header;

  618.     PLSR_PERSISTENCE_RESULT result;

  619.     uint32_t newestGeneration = 0UL;

  620.     uint32_t generationA;

  621.     uint32_t generationB;

  622.     uint32_t headerWordCount;

  623.     uint32_t dataWordCount;

  624.     uint32_t crcState;

  625.     uint32_t crc32;

  626.     uint32_t index;

  627.     uint8_t targetSlot;

  628.     uint8_t validA;

  629.     uint8_t validB;

  630. 

  631.     if (data == NULL)

  632.     {

  633.         return PLSR_PERSISTENCE_INVALID_ARGUMENT;

  634.     }

  635.     if (sizeof(PLSR_SFD_FLASH_RECORD) > PLSR_SFD_FLASH_SECTOR_SIZE)

  636.     {

  637.         return PLSR_PERSISTENCE_VERIFY_FAILED;

  638.     }

  639. 

  640.     slotA = PlsrPersistenceGetSfdSlot(0U);

  641.     slotB = PlsrPersistenceGetSfdSlot(1U);

  642.     validA = PlsrPersistenceSfdRecordIsValid(slotA);

  643.     validB = PlsrPersistenceSfdRecordIsValid(slotB);

  644. 

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

  646.     {

  647.         generationA = slotA->generation;

  648.         generationB = slotB->generation;

  649.         if (PlsrPersistenceGenerationIsNewer(generationB,

  650.                                              generationA)

  651.             != 0U)

  652.         {

  653.             newestGeneration = generationB;

  654.             target = slotA;

  655.             targetSlot = 0U;

  656.         }

  657.         else

  658.         {

  659.             newestGeneration = generationA;

  660.             target = slotB;

  661.             targetSlot = 1U;

  662.         }

  663.     }

  664.     else if (validA != 0U)

  665.     {

  666.         newestGeneration = slotA->generation;

  667.         target = slotB;

  668.         targetSlot = 1U;

  669.     }

  670.     else if (validB != 0U)

  671.     {

  672.         newestGeneration = slotB->generation;

  673.         target = slotA;

  674.         targetSlot = 0U;

  675.     }

  676.     else

  677.     {

  678.         target = slotA;

  679.         targetSlot = 0U;

  680.     }

  681. 

  682.     header.magic = PLSR_SFD_FLASH_MAGIC;

  683.     header.version = PLSR_SFD_FLASH_VERSION;

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

  685.     header.generation = newestGeneration + 1UL;

  686.     crcState = PlsrPersistenceCrc32Update(

  687.         0xFFFFFFFFUL,

  688.         (const volatile uint8_t *)&header,

  689.         (uint32_t)sizeof(header));

  690.     crcState = PlsrPersistenceCrc32Update(

  691.         crcState,

  692.         (const volatile uint8_t *)data,

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

  694.     crc32 = ~crcState;

  695. 

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

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

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

  699.     dataWords = (const uint32_t *)data;

  700.     targetWords = (volatile uint32_t *)target;

  701. 

  702.     result = PlsrPersistenceBeginSfdOperation();

  703.     if (result != PLSR_PERSISTENCE_OK)

  704.     {

  705.         return result;

  706.     }

  707. 

  708.     result = PlsrPersistenceEraseSfdSlot(targetSlot);

  709.     if (result != PLSR_PERSISTENCE_OK)

  710.     {

  711.         return PlsrPersistenceEndSfdOperation(result);

  712.     }

  713. 

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

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

  716.     {

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

  718.                                                headerWords[index]);

  719.         if (result != PLSR_PERSISTENCE_OK)

  720.         {

  721.             return PlsrPersistenceEndSfdOperation(result);

  722.         }

  723.     }

  724. 

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

  726.     {

  727.         result = PlsrPersistenceProgramSfdWord(

  728.             &targetWords[headerWordCount + index],

  729.             dataWords[index]);

  730.         if (result != PLSR_PERSISTENCE_OK)

  731.         {

  732.             return PlsrPersistenceEndSfdOperation(result);

  733.         }

  734.     }

  735. 

  736.     result = PlsrPersistenceProgramSfdWord(

  737.         &targetWords[headerWordCount + dataWordCount],

  738.         crc32);

  739.     if (result != PLSR_PERSISTENCE_OK)

  740.     {

  741.         return PlsrPersistenceEndSfdOperation(result);

  742.     }

  743. 

  744. #ifdef PLSR_HOST_TEST

  745.     if (PlsrHostSfdFault == PLSR_TEST_SFD_FAULT_VERIFY)

  746.     {

  747.         targetWords[1] ^= 1UL;

  748.         PlsrHostSfdFault = PLSR_TEST_SFD_FAULT_NONE;

  749.     }

  750. #endif

  751.     if (PlsrPersistenceSfdBodyMatches(targetWords,

  752.                                       &header,

  753.                                       data,

  754.                                       crc32)

  755.         == 0U)

  756.     {

  757.         return PlsrPersistenceEndSfdOperation(

  758.             PLSR_PERSISTENCE_VERIFY_FAILED);

  759.     }

  760. 

  761. #ifdef PLSR_HOST_TEST

  762.     if (PlsrHostSfdFault == PLSR_TEST_SFD_FAULT_BEFORE_COMMIT)

  763.     {

  764.         PlsrHostSfdFault = PLSR_TEST_SFD_FAULT_NONE;

  765.         return PlsrPersistenceEndSfdOperation(

  766.             PLSR_PERSISTENCE_PROGRAM_FAILED);

  767.     }

  768. #endif

  769. 

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

  771.     if (result != PLSR_PERSISTENCE_OK)

  772.     {

  773.         return PlsrPersistenceEndSfdOperation(result);

  774.     }

  775. 

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

  777.                  ? PLSR_PERSISTENCE_OK

  778.                  : PLSR_PERSISTENCE_VERIFY_FAILED;

  779.     return PlsrPersistenceEndSfdOperation(result);

  780. }

  781. 

  782. PLSR_PERSISTENCE_RESULT PlsrPersistenceEraseSfd(void)

  783. {

  784.     PLSR_PERSISTENCE_RESULT result;

  785. 

  786.     result = PlsrPersistenceBeginSfdOperation();

  787.     if (result != PLSR_PERSISTENCE_OK)

  788.     {

  789.         return result;

  790.     }

  791. 

  792.     result = PlsrPersistenceEraseSfdSlot(0U);

  793.     if (result == PLSR_PERSISTENCE_OK)

  794.     {

  795.         result = PlsrPersistenceEraseSfdSlot(1U);

  796.     }

  797. 

  798.     return PlsrPersistenceEndSfdOperation(result);

  799. }

  800. 

  801. #ifdef PLSR_HOST_TEST

  802. void PlsrPersistenceTestResetStorage(void)

  803. {

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

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

  806.     PlsrHostSfdFault = PLSR_TEST_SFD_FAULT_NONE;

  807. }

  808. 

  809. void PlsrPersistenceTestCorruptNewestHsd(void)

  810. {

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

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

  813.     uint8_t validA = PlsrPersistenceHsdRecordIsValid(slotA);

  814.     uint8_t validB = PlsrPersistenceHsdRecordIsValid(slotB);

  815.     volatile PLSR_HSD_BACKUP_RECORD *newest;

  816. 

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

  818.     {

  819.         return;

  820.     }

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

  822.     {

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

  824.                                                     slotA->generation)

  825.                   != 0U)

  826.                      ? slotB

  827.                      : slotA;

  828.     }

  829.     else

  830.     {

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

  832.     }

  833. 

  834.     newest->crc32 ^= 1UL;

  835. }

  836. 

  837. void PlsrPersistenceTestCorruptNewestSfd(void)

  838. {

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

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

  841.     uint8_t validA = PlsrPersistenceSfdRecordIsValid(slotA);

  842.     uint8_t validB = PlsrPersistenceSfdRecordIsValid(slotB);

  843.     volatile PLSR_SFD_FLASH_RECORD *newest;

  844. 

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

  846.     {

  847.         return;

  848.     }

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

  850.     {

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

  852.                                                     slotA->generation)

  853.                   != 0U)

  854.                      ? slotB

  855.                      : slotA;

  856.     }

  857.     else

  858.     {

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

  860.     }

  861. 

  862.     newest->crc32 ^= 1UL;

  863. }

  864. 

  865. void PlsrPersistenceTestSetSfdFault(PLSR_TEST_SFD_FAULT fault)

  866. {

  867.     PlsrHostSfdFault = fault;

  868. }

  869. #endif