yuwenhao
/
Modbus-rtu
1
0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
27 Commity
3 Gałęzie
138 MiB
 
 
 
 
 
 
Drzewo: 1dd8de5b2f
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '1dd8de5b2f'
${ noResults }
Modbus-rtu/PLSR/Src/plsr_persistence.c

800 wiersze
22 KiB
Czysty Wina Historia 

  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        (1U)

  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. 

  20. typedef struct

  21. {

  22.     uint32_t magic;

  23.     uint16_t version;

  24.     uint16_t payloadLength;

  25.     uint32_t generation;

  26.     PLSR_HSD_DATA data;

  27.     uint32_t crc32;

  28. } PLSR_HSD_BACKUP_RECORD;

  29. 

  30. typedef struct

  31. {

  32.     uint32_t magic;

  33.     uint16_t version;

  34.     uint16_t payloadLength;

  35.     uint32_t generation;

  36. } PLSR_SFD_FLASH_HEADER;

  37. 

  38. typedef struct

  39. {

  40.     uint32_t magic;

  41.     uint16_t version;

  42.     uint16_t payloadLength;

  43.     uint32_t generation;

  44.     PLSR_SFD_DATA data;

  45.     uint32_t crc32;

  46. } PLSR_SFD_FLASH_RECORD;

  47. 

  48. #ifdef PLSR_HOST_TEST

  49. static PLSR_HSD_BACKUP_RECORD PlsrHostBackupSlots[2];

  50. static PLSR_SFD_FLASH_RECORD PlsrHostSfdSlots[2];

  51. static PLSR_TEST_SFD_FAULT PlsrHostSfdFault;

  52. #else

  53. #include "stm32f4xx.h"

  54. #include "stm32f4xx_hal.h"

  55. #include "stm32f4xx_hal_flash_ex.h"

  56. #endif

  57. 

  58. static uint32_t PlsrPersistenceCrc32Update(uint32_t crc,

  59.                                           const volatile uint8_t *data,

  60.                                           uint32_t length)

  61. {

  62.     uint32_t index;

  63.     uint8_t bit;

  64. 

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

  66.     {

  67.         crc ^= data[index];

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

  69.         {

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

  71.             {

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

  73.             }

  74.             else

  75.             {

  76.                 crc >>= 1U;

  77.             }

  78.         }

  79.     }

  80. 

  81.     return crc;

  82. }

  83. 

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

  85.                                     uint32_t length)

  86. {

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

  88. }

  89. 

  90. static volatile PLSR_HSD_BACKUP_RECORD *PlsrPersistenceGetHsdSlot(

  91.     uint8_t slot)

  92. {

  93. #ifdef PLSR_HOST_TEST

  94.     return &PlsrHostBackupSlots[slot];

  95. #else

  96.     uint32_t offset = PLSR_BACKUP_SLOT_A_OFFSET

  97.                       + (uint32_t)slot * PLSR_BACKUP_SLOT_STRIDE;

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

  99. #endif

  100. }

  101. 

  102. static uint8_t PlsrPersistenceHsdRecordIsValid(

  103.     const volatile PLSR_HSD_BACKUP_RECORD *record)

  104. {

  105.     uint32_t expectedCrc;

  106. 

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

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

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

  110.     {

  111.         return 0U;

  112.     }

  113. 

  114.     expectedCrc = PlsrPersistenceCrc32(

  115.         (const volatile uint8_t *)record,

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

  117. 

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

  119. }

  120. 

  121. static uint8_t PlsrPersistenceGenerationIsNewer(uint32_t left,

  122.                                                 uint32_t right)

  123. {

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

  125. }

  126. 

  127. static volatile PLSR_SFD_FLASH_RECORD *PlsrPersistenceGetSfdSlot(

  128.     uint8_t slot)

  129. {

  130. #ifdef PLSR_HOST_TEST

  131.     return &PlsrHostSfdSlots[slot];

  132. #else

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

  134.                                     : PLSR_SFD_FLASH_SLOT_B_ADDRESS;

  135.     return (volatile PLSR_SFD_FLASH_RECORD *)address;

  136. #endif

  137. }

  138. 

  139. static uint8_t PlsrPersistenceSfdRecordIsValid(

  140.     const volatile PLSR_SFD_FLASH_RECORD *record)

  141. {

  142.     uint32_t expectedCrc;

  143. 

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

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

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

  147.     {

  148.         return 0U;

  149.     }

  150. 

  151.     expectedCrc = PlsrPersistenceCrc32(

  152.         (const volatile uint8_t *)record,

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

  154. 

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

  156. }

  157. 

  158. static void PlsrPersistenceCopySfdFromVolatile(

  159.     PLSR_SFD_DATA *destination,

  160.     const volatile PLSR_SFD_DATA *source)

  161. {

  162.     uint16_t index;

  163. 

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

  165.     {

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

  167.     }

  168. }

  169. 

  170. static void PlsrPersistenceApplySfdDefaults(PLSR_SFD_DATA *data)

  171. {

  172.     uint16_t axisOffset;

  173.     uint16_t parameterOffset;

  174.     uint8_t axis;

  175.     uint8_t parameterSet;

  176. 

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

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

  179.     {

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

  181. 

  182.         /* Explicit Xinje defaults from the SFD parameter table. */

  183.         data->config[axisOffset + 7U] = 10;

  184.         data->config[axisOffset + 27U] = 20;

  185.         data->config[axisOffset + 43U] = 0x0201;

  186. 

  187.         for (parameterSet = 0U;

  188.              parameterSet < PLSR_SFD_PARAMETER_SET_COUNT;

  189.              parameterSet++)

  190.         {

  191.             parameterOffset = (uint16_t)(

  192.                 axisOffset + PLSR_SFD_PARAMETER_SET_OFFSET

  193.                 + (uint16_t)parameterSet * PLSR_SFD_PARAMETER_SET_STRIDE);

  194.             data->config[parameterOffset + 6U] =

  195.                 (int32_t)(PLSR_SFD_DEFAULT_MAX_SPEED & 0xFFFFUL);

  196.             data->config[parameterOffset + 7U] =

  197.                 (int32_t)(PLSR_SFD_DEFAULT_MAX_SPEED >> 16U);

  198.         }

  199.     }

  200. }

  201. 

  202. static PLSR_PERSISTENCE_RESULT PlsrPersistenceBeginSfdOperation(void)

  203. {

  204. #ifdef PLSR_HOST_TEST

  205.     return PLSR_PERSISTENCE_OK;

  206. #else

  207.     if (HAL_FLASH_Unlock() != HAL_OK)

  208.     {

  209.         return PLSR_PERSISTENCE_PROGRAM_FAILED;

  210.     }

  211. 

  212.     __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR

  213.                            | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR

  214.                            | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);

  215.     return PLSR_PERSISTENCE_OK;

  216. #endif

  217. }

  218. 

  219. static PLSR_PERSISTENCE_RESULT PlsrPersistenceEndSfdOperation(

  220.     PLSR_PERSISTENCE_RESULT result)

  221. {

  222. #ifdef PLSR_HOST_TEST

  223.     return result;

  224. #else

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

  226.     {

  227.         return PLSR_PERSISTENCE_PROGRAM_FAILED;

  228.     }

  229.     return result;

  230. #endif

  231. }

  232. 

  233. static PLSR_PERSISTENCE_RESULT PlsrPersistenceEraseSfdSlot(uint8_t slot)

  234. {

  235. #ifdef PLSR_HOST_TEST

  236.     if (PlsrHostSfdFault == PLSR_TEST_SFD_FAULT_ERASE)

  237.     {

  238.         PlsrHostSfdFault = PLSR_TEST_SFD_FAULT_NONE;

  239.         return PLSR_PERSISTENCE_ERASE_FAILED;

  240.     }

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

  242.                  0xFF,

  243.                  sizeof(PlsrHostSfdSlots[slot]));

  244.     return PLSR_PERSISTENCE_OK;

  245. #else

  246.     FLASH_EraseInitTypeDef erase;

  247.     uint32_t sectorError = 0xFFFFFFFFUL;

  248. 

  249.     erase.TypeErase = FLASH_TYPEERASE_SECTORS;

  250.     erase.VoltageRange = FLASH_VOLTAGE_RANGE_3;

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

  252.     erase.NbSectors = 1U;

  253. 

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

  255.                ? PLSR_PERSISTENCE_OK

  256.                : PLSR_PERSISTENCE_ERASE_FAILED;

  257. #endif

  258. }

  259. 

  260. static PLSR_PERSISTENCE_RESULT PlsrPersistenceProgramSfdWord(

  261.     volatile uint32_t *destination,

  262.     uint32_t value)

  263. {

  264. #ifdef PLSR_HOST_TEST

  265.     if (PlsrHostSfdFault == PLSR_TEST_SFD_FAULT_PROGRAM)

  266.     {

  267.         PlsrHostSfdFault = PLSR_TEST_SFD_FAULT_NONE;

  268.         return PLSR_PERSISTENCE_PROGRAM_FAILED;

  269.     }

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

  271.     {

  272.         return PLSR_PERSISTENCE_PROGRAM_FAILED;

  273.     }

  274.     *destination &= value;

  275.     return PLSR_PERSISTENCE_OK;

  276. #else

  277.     return (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD,

  278.                               (uint32_t)destination,

  279.                               value)

  280.             == HAL_OK)

  281.                ? PLSR_PERSISTENCE_OK

  282.                : PLSR_PERSISTENCE_PROGRAM_FAILED;

  283. #endif

  284. }

  285. 

  286. static uint8_t PlsrPersistenceSfdBodyMatches(

  287.     const volatile uint32_t *destination,

  288.     const PLSR_SFD_FLASH_HEADER *header,

  289.     const PLSR_SFD_DATA *data,

  290.     uint32_t crc32)

  291. {

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

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

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

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

  296.     uint32_t index;

  297. 

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

  299.     {

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

  301.         {

  302.             return 0U;

  303.         }

  304.     }

  305. 

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

  307.     {

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

  309.         {

  310.             return 0U;

  311.         }

  312.     }

  313. 

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

  315.     {

  316.         return 0U;

  317.     }

  318.     return 1U;

  319. }

  320. 

  321. static void PlsrPersistenceCopyHsdFromVolatile(

  322.     PLSR_HSD_DATA *destination,

  323.     const volatile PLSR_HSD_DATA *source)

  324. {

  325.     uint16_t index;

  326. 

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

  328.     {

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

  330.     }

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

  332.     {

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

  334.     }

  335. }

  336. 

  337. static void PlsrPersistenceWriteRecord(

  338.     volatile PLSR_HSD_BACKUP_RECORD *destination,

  339.     const PLSR_HSD_BACKUP_RECORD *source)

  340. {

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

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

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

  344.                                     / sizeof(uint32_t));

  345.     uint32_t index;

  346. 

  347.     destination->magic = 0UL;

  348. #ifndef PLSR_HOST_TEST

  349.     __DMB();

  350. #endif

  351. 

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

  353.     {

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

  355.     }

  356. 

  357. #ifndef PLSR_HOST_TEST

  358.     __DMB();

  359. #endif

  360.     destination->magic = PLSR_HSD_BACKUP_MAGIC;

  361. #ifndef PLSR_HOST_TEST

  362.     __DMB();

  363. #endif

  364. }

  365. 

  366. PLSR_PERSISTENCE_RESULT PlsrPersistenceLoadHsd(PLSR_HSD_DATA *data)

  367. {

  368.     volatile PLSR_HSD_BACKUP_RECORD *slotA;

  369.     volatile PLSR_HSD_BACKUP_RECORD *slotB;

  370.     const volatile PLSR_HSD_BACKUP_RECORD *selected;

  371.     uint32_t generationA;

  372.     uint32_t generationB;

  373.     uint8_t validA;

  374.     uint8_t validB;

  375. 

  376.     if (data == NULL)

  377.     {

  378.         return PLSR_PERSISTENCE_INVALID_ARGUMENT;

  379.     }

  380. 

  381.     slotA = PlsrPersistenceGetHsdSlot(0U);

  382.     slotB = PlsrPersistenceGetHsdSlot(1U);

  383.     validA = PlsrPersistenceHsdRecordIsValid(slotA);

  384.     validB = PlsrPersistenceHsdRecordIsValid(slotB);

  385. 

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

  387.     {

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

  389.         return PLSR_PERSISTENCE_DEFAULTED;

  390.     }

  391. 

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

  393.     {

  394.         generationA = slotA->generation;

  395.         generationB = slotB->generation;

  396.         selected = (PlsrPersistenceGenerationIsNewer(generationB,

  397.                                                        generationA)

  398.                     != 0U)

  399.                        ? slotB

  400.                        : slotA;

  401.     }

  402.     else

  403.     {

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

  405.     }

  406. 

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

  408.     return PLSR_PERSISTENCE_OK;

  409. }

  410. 

  411. PLSR_PERSISTENCE_RESULT PlsrPersistenceSaveHsd(const PLSR_HSD_DATA *data)

  412. {

  413.     volatile PLSR_HSD_BACKUP_RECORD *slotA;

  414.     volatile PLSR_HSD_BACKUP_RECORD *slotB;

  415.     volatile PLSR_HSD_BACKUP_RECORD *target;

  416.     PLSR_HSD_BACKUP_RECORD record;

  417.     uint32_t newestGeneration = 0UL;

  418.     uint32_t generationA;

  419.     uint32_t generationB;

  420.     uint8_t validA;

  421.     uint8_t validB;

  422. 

  423.     if (data == NULL)

  424.     {

  425.         return PLSR_PERSISTENCE_INVALID_ARGUMENT;

  426.     }

  427.     if (sizeof(PLSR_HSD_BACKUP_RECORD) > PLSR_BACKUP_SLOT_STRIDE)

  428.     {

  429.         return PLSR_PERSISTENCE_VERIFY_FAILED;

  430.     }

  431. 

  432.     slotA = PlsrPersistenceGetHsdSlot(0U);

  433.     slotB = PlsrPersistenceGetHsdSlot(1U);

  434.     validA = PlsrPersistenceHsdRecordIsValid(slotA);

  435.     validB = PlsrPersistenceHsdRecordIsValid(slotB);

  436. 

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

  438.     {

  439.         generationA = slotA->generation;

  440.         generationB = slotB->generation;

  441.         if (PlsrPersistenceGenerationIsNewer(generationB,

  442.                                               generationA)

  443.             != 0U)

  444.         {

  445.             newestGeneration = generationB;

  446.             target = slotA;

  447.         }

  448.         else

  449.         {

  450.             newestGeneration = generationA;

  451.             target = slotB;

  452.         }

  453.     }

  454.     else if (validA != 0U)

  455.     {

  456.         newestGeneration = slotA->generation;

  457.         target = slotB;

  458.     }

  459.     else if (validB != 0U)

  460.     {

  461.         newestGeneration = slotB->generation;

  462.         target = slotA;

  463.     }

  464.     else

  465.     {

  466.         target = slotA;

  467.     }

  468. 

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

  470.     record.magic = PLSR_HSD_BACKUP_MAGIC;

  471.     record.version = PLSR_HSD_BACKUP_VERSION;

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

  473.     record.generation = newestGeneration + 1UL;

  474.     record.data = *data;

  475.     record.crc32 = PlsrPersistenceCrc32(

  476.         (const volatile uint8_t *)&record,

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

  478. 

  479.     PlsrPersistenceWriteRecord(target, &record);

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

  481.                ? PLSR_PERSISTENCE_OK

  482.                : PLSR_PERSISTENCE_VERIFY_FAILED;

  483. }

  484. 

  485. void PlsrPersistenceResetHsd(void)

  486. {

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

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

  489. #ifndef PLSR_HOST_TEST

  490.     __DMB();

  491. #endif

  492. }

  493. 

  494. PLSR_PERSISTENCE_RESULT PlsrPersistenceLoadSfd(PLSR_SFD_DATA *data)

  495. {

  496.     volatile PLSR_SFD_FLASH_RECORD *slotA;

  497.     volatile PLSR_SFD_FLASH_RECORD *slotB;

  498.     const volatile PLSR_SFD_FLASH_RECORD *selected;

  499.     uint32_t generationA;

  500.     uint32_t generationB;

  501.     uint8_t validA;

  502.     uint8_t validB;

  503. 

  504.     if (data == NULL)

  505.     {

  506.         return PLSR_PERSISTENCE_INVALID_ARGUMENT;

  507.     }

  508. 

  509.     slotA = PlsrPersistenceGetSfdSlot(0U);

  510.     slotB = PlsrPersistenceGetSfdSlot(1U);

  511.     validA = PlsrPersistenceSfdRecordIsValid(slotA);

  512.     validB = PlsrPersistenceSfdRecordIsValid(slotB);

  513. 

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

  515.     {

  516.         PlsrPersistenceApplySfdDefaults(data);

  517.         return PLSR_PERSISTENCE_DEFAULTED;

  518.     }

  519. 

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

  521.     {

  522.         generationA = slotA->generation;

  523.         generationB = slotB->generation;

  524.         selected = (PlsrPersistenceGenerationIsNewer(generationB,

  525.                                                        generationA)

  526.                     != 0U)

  527.                        ? slotB

  528.                        : slotA;

  529.     }

  530.     else

  531.     {

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

  533.     }

  534. 

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

  536.     return PLSR_PERSISTENCE_OK;

  537. }

  538. 

  539. PLSR_PERSISTENCE_RESULT PlsrPersistenceSaveSfd(const PLSR_SFD_DATA *data)

  540. {

  541.     volatile PLSR_SFD_FLASH_RECORD *slotA;

  542.     volatile PLSR_SFD_FLASH_RECORD *slotB;

  543.     volatile PLSR_SFD_FLASH_RECORD *target;

  544.     volatile uint32_t *targetWords;

  545.     const uint32_t *headerWords;

  546.     const uint32_t *dataWords;

  547.     PLSR_SFD_FLASH_HEADER header;

  548.     PLSR_PERSISTENCE_RESULT result;

  549.     uint32_t newestGeneration = 0UL;

  550.     uint32_t generationA;

  551.     uint32_t generationB;

  552.     uint32_t headerWordCount;

  553.     uint32_t dataWordCount;

  554.     uint32_t crcState;

  555.     uint32_t crc32;

  556.     uint32_t index;

  557.     uint8_t targetSlot;

  558.     uint8_t validA;

  559.     uint8_t validB;

  560. 

  561.     if (data == NULL)

  562.     {

  563.         return PLSR_PERSISTENCE_INVALID_ARGUMENT;

  564.     }

  565.     if (sizeof(PLSR_SFD_FLASH_RECORD) > PLSR_SFD_FLASH_SECTOR_SIZE)

  566.     {

  567.         return PLSR_PERSISTENCE_VERIFY_FAILED;

  568.     }

  569. 

  570.     slotA = PlsrPersistenceGetSfdSlot(0U);

  571.     slotB = PlsrPersistenceGetSfdSlot(1U);

  572.     validA = PlsrPersistenceSfdRecordIsValid(slotA);

  573.     validB = PlsrPersistenceSfdRecordIsValid(slotB);

  574. 

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

  576.     {

  577.         generationA = slotA->generation;

  578.         generationB = slotB->generation;

  579.         if (PlsrPersistenceGenerationIsNewer(generationB,

  580.                                              generationA)

  581.             != 0U)

  582.         {

  583.             newestGeneration = generationB;

  584.             target = slotA;

  585.             targetSlot = 0U;

  586.         }

  587.         else

  588.         {

  589.             newestGeneration = generationA;

  590.             target = slotB;

  591.             targetSlot = 1U;

  592.         }

  593.     }

  594.     else if (validA != 0U)

  595.     {

  596.         newestGeneration = slotA->generation;

  597.         target = slotB;

  598.         targetSlot = 1U;

  599.     }

  600.     else if (validB != 0U)

  601.     {

  602.         newestGeneration = slotB->generation;

  603.         target = slotA;

  604.         targetSlot = 0U;

  605.     }

  606.     else

  607.     {

  608.         target = slotA;

  609.         targetSlot = 0U;

  610.     }

  611. 

  612.     header.magic = PLSR_SFD_FLASH_MAGIC;

  613.     header.version = PLSR_SFD_FLASH_VERSION;

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

  615.     header.generation = newestGeneration + 1UL;

  616.     crcState = PlsrPersistenceCrc32Update(

  617.         0xFFFFFFFFUL,

  618.         (const volatile uint8_t *)&header,

  619.         (uint32_t)sizeof(header));

  620.     crcState = PlsrPersistenceCrc32Update(

  621.         crcState,

  622.         (const volatile uint8_t *)data,

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

  624.     crc32 = ~crcState;

  625. 

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

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

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

  629.     dataWords = (const uint32_t *)data;

  630.     targetWords = (volatile uint32_t *)target;

  631. 

  632.     result = PlsrPersistenceBeginSfdOperation();

  633.     if (result != PLSR_PERSISTENCE_OK)

  634.     {

  635.         return result;

  636.     }

  637. 

  638.     result = PlsrPersistenceEraseSfdSlot(targetSlot);

  639.     if (result != PLSR_PERSISTENCE_OK)

  640.     {

  641.         return PlsrPersistenceEndSfdOperation(result);

  642.     }

  643. 

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

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

  646.     {

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

  648.                                                headerWords[index]);

  649.         if (result != PLSR_PERSISTENCE_OK)

  650.         {

  651.             return PlsrPersistenceEndSfdOperation(result);

  652.         }

  653.     }

  654. 

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

  656.     {

  657.         result = PlsrPersistenceProgramSfdWord(

  658.             &targetWords[headerWordCount + index],

  659.             dataWords[index]);

  660.         if (result != PLSR_PERSISTENCE_OK)

  661.         {

  662.             return PlsrPersistenceEndSfdOperation(result);

  663.         }

  664.     }

  665. 

  666.     result = PlsrPersistenceProgramSfdWord(

  667.         &targetWords[headerWordCount + dataWordCount],

  668.         crc32);

  669.     if (result != PLSR_PERSISTENCE_OK)

  670.     {

  671.         return PlsrPersistenceEndSfdOperation(result);

  672.     }

  673. 

  674. #ifdef PLSR_HOST_TEST

  675.     if (PlsrHostSfdFault == PLSR_TEST_SFD_FAULT_VERIFY)

  676.     {

  677.         targetWords[1] ^= 1UL;

  678.         PlsrHostSfdFault = PLSR_TEST_SFD_FAULT_NONE;

  679.     }

  680. #endif

  681.     if (PlsrPersistenceSfdBodyMatches(targetWords,

  682.                                       &header,

  683.                                       data,

  684.                                       crc32)

  685.         == 0U)

  686.     {

  687.         return PlsrPersistenceEndSfdOperation(

  688.             PLSR_PERSISTENCE_VERIFY_FAILED);

  689.     }

  690. 

  691. #ifdef PLSR_HOST_TEST

  692.     if (PlsrHostSfdFault == PLSR_TEST_SFD_FAULT_BEFORE_COMMIT)

  693.     {

  694.         PlsrHostSfdFault = PLSR_TEST_SFD_FAULT_NONE;

  695.         return PlsrPersistenceEndSfdOperation(

  696.             PLSR_PERSISTENCE_PROGRAM_FAILED);

  697.     }

  698. #endif

  699. 

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

  701.     if (result != PLSR_PERSISTENCE_OK)

  702.     {

  703.         return PlsrPersistenceEndSfdOperation(result);

  704.     }

  705. 

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

  707.                  ? PLSR_PERSISTENCE_OK

  708.                  : PLSR_PERSISTENCE_VERIFY_FAILED;

  709.     return PlsrPersistenceEndSfdOperation(result);

  710. }

  711. 

  712. PLSR_PERSISTENCE_RESULT PlsrPersistenceEraseSfd(void)

  713. {

  714.     PLSR_PERSISTENCE_RESULT result;

  715. 

  716.     result = PlsrPersistenceBeginSfdOperation();

  717.     if (result != PLSR_PERSISTENCE_OK)

  718.     {

  719.         return result;

  720.     }

  721. 

  722.     result = PlsrPersistenceEraseSfdSlot(0U);

  723.     if (result == PLSR_PERSISTENCE_OK)

  724.     {

  725.         result = PlsrPersistenceEraseSfdSlot(1U);

  726.     }

  727. 

  728.     return PlsrPersistenceEndSfdOperation(result);

  729. }

  730. 

  731. #ifdef PLSR_HOST_TEST

  732. void PlsrPersistenceTestResetStorage(void)

  733. {

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

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

  736.     PlsrHostSfdFault = PLSR_TEST_SFD_FAULT_NONE;

  737. }

  738. 

  739. void PlsrPersistenceTestCorruptNewestHsd(void)

  740. {

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

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

  743.     uint8_t validA = PlsrPersistenceHsdRecordIsValid(slotA);

  744.     uint8_t validB = PlsrPersistenceHsdRecordIsValid(slotB);

  745.     volatile PLSR_HSD_BACKUP_RECORD *newest;

  746. 

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

  748.     {

  749.         return;

  750.     }

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

  752.     {

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

  754.                                                     slotA->generation)

  755.                   != 0U)

  756.                      ? slotB

  757.                      : slotA;

  758.     }

  759.     else

  760.     {

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

  762.     }

  763. 

  764.     newest->crc32 ^= 1UL;

  765. }

  766. 

  767. void PlsrPersistenceTestCorruptNewestSfd(void)

  768. {

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

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

  771.     uint8_t validA = PlsrPersistenceSfdRecordIsValid(slotA);

  772.     uint8_t validB = PlsrPersistenceSfdRecordIsValid(slotB);

  773.     volatile PLSR_SFD_FLASH_RECORD *newest;

  774. 

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

  776.     {

  777.         return;

  778.     }

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

  780.     {

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

  782.                                                     slotA->generation)

  783.                   != 0U)

  784.                      ? slotB

  785.                      : slotA;

  786.     }

  787.     else

  788.     {

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

  790.     }

  791. 

  792.     newest->crc32 ^= 1UL;

  793. }

  794. 

  795. void PlsrPersistenceTestSetSfdFault(PLSR_TEST_SFD_FAULT fault)

  796. {

  797.     PlsrHostSfdFault = fault;

  798. }

  799. #endif