sundp
/
STM32CubeWL
mirror of https://github.com/STMicroelectronics/STM32CubeWL.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
STM32CubeWL/Middlewares/Third_Party/LoRaWAN/LmHandler/Packages/LmhpDataDistribution.c

392 lines
12 KiB
C
Raw Blame History

/**
******************************************************************************
* @file LmhpDataDistribution.c
* @author MCD Application Team
* @brief Implements the Data Distribution Agent
******************************************************************************
* @attention
*
* <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under BSD 3-Clause license,
* the "License"; You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
* opensource.org/licenses/BSD-3-Clause
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "platform.h"
#include "LmhpDataDistribution.h"
#include "LmhpClockSync.h"
#include "LmhpRemoteMcastSetup.h"
#include "LmhpFragmentation.h"
#include "LmhpFirmwareManagement.h"
#include "LmHandler.h"
#include "mw_log_conf.h"
#include "utilities.h"
#include "flash_if.h"
#include "se_def_metadata.h"
#define SFU_FWIMG_COMMON_C
#include "sfu_fwimg_regions.h"
/* Private typedef -----------------------------------------------------------*/
/*!
* Structure containing values related to the management of multi-images in Flash
*/
typedef struct
{
uint32_t MaxSizeInBytes; /*!< The maximum allowed size for the FwImage in User Flash (in Bytes) */
uint32_t DownloadAddr; /*!< The download address for the FwImage in UserFlash */
uint32_t ImageOffsetInBytes; /*!< Image write starts at this offset */
uint32_t ExecutionAddr; /*!< The execution address for the FwImage in UserFlash */
} FwImageFlashTypeDef;
/* Private define ------------------------------------------------------------*/
/*!
* Defines the maximum size for the buffer receiving the fragmentation result.
*
* \remark By default FragDecoder.h defines:
* \ref FRAG_MAX_NB 313
* \ref FRAG_MAX_SIZE 216
*
* In interop test mode will be
* \ref FRAG_MAX_NB 21
* \ref FRAG_MAX_SIZE 50
*
* FileSize = FRAG_MAX_NB * FRAG_MAX_SIZE
*
* If bigger file size is to be received or is fragmented differently
* one must update those parameters.
*
* \remark Memory allocation is done at compile time. Several options have to be foreseen
* in order to optimize the memory. Will depend of the Memory management used
* Could be Dynamic allocation --> malloc method
* Variable Length Array --> VLA method
* pseudo dynamic allocation --> memory pool method
* Other option :
* In place of using the caching memory method we can foreseen to have a direct
* flash memory copy. This solution will depend of the SBSFU constraint
*
*/
#define UNFRAGMENTED_DATA_SIZE ( FRAG_MAX_NB * FRAG_MAX_SIZE )
/*!
* Starting offset to add to the first address
*/
#define SFU_IMG_IMAGE_OFFSET ((uint32_t)512U)
/*!
* Size of header to write in Swap sector to trigger installation
*/
#define INSTALLED_LENGTH ((uint32_t)512U)
#define SFU_IMG_SWAP_REGION_SIZE ((uint32_t)(SWAP_END - SWAP_START + 1U))
#define SFU_IMG_SWAP_REGION_BEGIN_VALUE ((uint32_t)SWAP_START)
#define SFU_IMG_SLOT_DWL_REGION_BEGIN_VALUE ((uint32_t)SLOT_DWL_1_START)
#define SFU_IMG_SLOT_DWL_REGION_SIZE ((uint32_t)(SLOT_DWL_1_END - SLOT_DWL_1_START + 1U))
/* Private macro -------------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/**
* @brief Init `data` buffer of `size` starting at address `addr`
* @param addr Address start index to erase.
* @param size number of bytes.
* @retval status Init operation status [0: Success, -1 Fail]
*/
static uint8_t FragDecoderErase(uint32_t addr, uint32_t size);
/**
* @brief Write `data` buffer of `size` starting at address `addr`
* @param addr Address start index to write to.
* @param data Data buffer to be written.
* @param size Size of data buffer to be written.
* @retval status Write operation status [0: Success, -1 Fail]
*/
static uint8_t FragDecoderWrite(uint32_t addr, uint8_t *data, uint32_t size);
/**
* @brief Reads `data` buffer of `size` starting at address `addr`
* @param addr Address start index to read from.
* @param data Data buffer to be read.
* @param size Size of data buffer to be read.
* @retval status Read operation status [0: Success, -1 Fail]
*/
static uint8_t FragDecoderRead(uint32_t addr, uint8_t *data, uint32_t size);
/**
* @brief Callback to get the current progress status of the fragmentation session
* @param fragCounter fragment counter
* @param fragNb number of fragments
* @param fragSize size of fragments
* @param fragNbLost number of lost fragments
* @retval None
*/
static void OnFragProgress(uint16_t fragCounter, uint16_t fragNb, uint8_t fragSize, uint16_t fragNbLost);
/**
* @brief Callback to notify when the fragmentation session is finished
* @param status status of the fragmentation process
* @param size size of the fragmented data block
* @retval None
*/
static void OnFragDone(int32_t status, uint32_t size);
#if (INTEROP_TEST_MODE == 0)
/**
* @brief Run FW Update process.
* @param None
* @retval None
*/
static void FwUpdateAgentRun(void);
/**
* @brief Provide the area descriptor to write a FW image in Flash.
* This function is used by the User Application to know where to store
* a new Firmware Image before asking for its installation.
* @param pArea pointer to area descriptor
* @retval HAL_OK if successful, otherwise HAL_ERROR
*/
static uint32_t FwUpdateAgentGetDownloadAreaInfo(FwImageFlashTypeDef *pArea);
/**
* @brief Write in Flash the next header image to install.
* This function is used by the User Application to request a Firmware installation (at next reboot).
* @param fw_header FW header of the FW to be installed
* @retval HAL_OK if successful, otherwise HAL_ERROR
*/
static uint32_t FwUpdateAgentInstallAtNextReset(uint8_t *fw_header);
#endif /* INTEROP_TEST_MODE == 0 */
/* Private variables ---------------------------------------------------------*/
static LmhpFragmentationParams_t FragmentationParams =
{
.DecoderCallbacks =
{
.FragDecoderErase = FragDecoderErase,
.FragDecoderWrite = FragDecoderWrite,
.FragDecoderRead = FragDecoderRead,
},
.OnProgress = OnFragProgress,
.OnDone = OnFragDone
};
/*
* Indicates if the file transfer is done
*/
static volatile bool IsFileTransferDone = false;
#if (INTEROP_TEST_MODE == 1) /*write fragment in RAM - Caching mode*/
/*
* Un-fragmented data storage.
*/
static uint8_t UnfragmentedData[UNFRAGMENTED_DATA_SIZE];
#endif /* INTEROP_TEST_MODE == 1 */
/* Exported functions ---------------------------------------------------------*/
LmHandlerErrorStatus_t LmhpDataDistributionInit(void)
{
if (LmHandlerPackageRegister(PACKAGE_ID_CLOCK_SYNC, NULL) != LORAMAC_HANDLER_SUCCESS)
{
return LORAMAC_HANDLER_ERROR;
}
else if (LmHandlerPackageRegister(PACKAGE_ID_REMOTE_MCAST_SETUP, NULL) != LORAMAC_HANDLER_SUCCESS)
{
return LORAMAC_HANDLER_ERROR;
}
else if (LmHandlerPackageRegister(PACKAGE_ID_FRAGMENTATION, &FragmentationParams) != LORAMAC_HANDLER_SUCCESS)
{
return LORAMAC_HANDLER_ERROR;
}
else if (LmHandlerPackageRegister(PACKAGE_ID_FIRMWARE_MANAGEMENT, NULL) != LORAMAC_HANDLER_SUCCESS)
{
return LORAMAC_HANDLER_ERROR;
}
return LORAMAC_HANDLER_SUCCESS;
}
LmHandlerErrorStatus_t LmhpDataDistributionPackageRegister(uint8_t id, LmhPackage_t **package)
{
if (package == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
switch (id)
{
case PACKAGE_ID_CLOCK_SYNC:
{
*package = LmphClockSyncPackageFactory();
break;
}
case PACKAGE_ID_REMOTE_MCAST_SETUP:
{
*package = LmhpRemoteMcastSetupPackageFactory();
break;
}
case PACKAGE_ID_FRAGMENTATION:
{
*package = LmhpFragmentationPackageFactory();
break;
}
case PACKAGE_ID_FIRMWARE_MANAGEMENT:
{
*package = LmhpFirmwareManagementPackageFactory();
break;
}
}
return LORAMAC_HANDLER_SUCCESS;
}
/* Private functions ---------------------------------------------------------*/
static uint8_t FragDecoderErase(uint32_t addr, uint32_t size)
{
#if (INTEROP_TEST_MODE == 1)
for (uint32_t i = 0; i < size; i++)
{
UnfragmentedData[addr + i] = 0xFF;
}
#else /* INTEROP_TEST_MODE == 0 */
if (FLASH_Erase((void *)(SlotStartAdd[SLOT_DWL_1] + addr), size) != HAL_OK)
{
return -1;
}
#endif /* INTEROP_TEST_MODE */
return 0; /* Success */
}
static uint8_t FragDecoderWrite(uint32_t addr, uint8_t *data, uint32_t size)
{
if (size >= UNFRAGMENTED_DATA_SIZE)
{
return (uint8_t) - 1; /* Fail */
}
#if (INTEROP_TEST_MODE == 1) /*write fragment in RAM - Caching mode*/
for (uint32_t i = 0; i < size; i++)
{
UnfragmentedData[addr + i] = data[i];
}
#else /* INTEROP_TEST_MODE == 0 */
if (FLASH_Write(SlotStartAdd[SLOT_DWL_1] + addr, data, size) != HAL_OK)
{
return -1;
}
#endif /* INTEROP_TEST_MODE */
return 0; /* Success */
}
static uint8_t FragDecoderRead(uint32_t addr, uint8_t *data, uint32_t size)
{
if (size >= UNFRAGMENTED_DATA_SIZE)
{
return (uint8_t) - 1; /* Fail */
}
#if (INTEROP_TEST_MODE == 1) /*Read fragment in RAM - Caching mode*/
for (uint32_t i = 0; i < size; i++)
{
data[i] = UnfragmentedData[addr + i];
}
#else /* INTEROP_TEST_MODE == 0 */
if (FLASH_Read((void *)(SlotStartAdd[SLOT_DWL_1] + addr), data, size) != HAL_OK)
{
return -1;
}
#endif /* INTEROP_TEST_MODE */
return 0; /* Success */
}
static void OnFragProgress(uint16_t fragCounter, uint16_t fragNb, uint8_t fragSize, uint16_t fragNbLost)
{
#if (INTEROP_TEST_MODE == 1)
/* BSP_LED_On(LED_BLUE); */
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_15, GPIO_PIN_SET);
#endif /* INTEROP_TEST_MODE == 1 */
MW_LOG(TS_OFF, VLEVEL_M, "\r\n....... FRAG_DECODER in Progress .......\r\n");
MW_LOG(TS_OFF, VLEVEL_M, "RECEIVED : %5d / %5d Fragments\r\n", fragCounter, fragNb);
MW_LOG(TS_OFF, VLEVEL_M, " %5d / %5d Bytes\r\n", fragCounter * fragSize, fragNb * fragSize);
MW_LOG(TS_OFF, VLEVEL_M, "LOST : %7d Fragments\r\n\r\n", fragNbLost);
}
static void OnFragDone(int32_t status, uint32_t size)
{
IsFileTransferDone = true;
#if (INTEROP_TEST_MODE == 0)
/* Do a request to Run the Secure boot - The file is already in flash */
FwUpdateAgentRun();
#else
/* BSP_LED_Off(LED_BLUE); */
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_15, GPIO_PIN_RESET);
#endif /* INTEROP_TEST_MODE == 1 */
MW_LOG(TS_OFF, VLEVEL_M, "\r\n....... FRAG_DECODER Finished .......\r\n");
MW_LOG(TS_OFF, VLEVEL_M, "STATUS : %d\r\n", status);
}
#if (INTEROP_TEST_MODE == 0)
static void FwUpdateAgentRun(void)
{
HAL_StatusTypeDef ret = HAL_ERROR;
uint8_t fw_header_dwl_slot[SE_FW_HEADER_TOT_LEN];
FwImageFlashTypeDef fw_image_dwl_area;
/* Get Info about the download area */
if (FwUpdateAgentGetDownloadAreaInfo(&fw_image_dwl_area) != HAL_ERROR)
{
/* Read header in slot 1 */
ret = FLASH_Read(fw_header_dwl_slot, (void *) fw_image_dwl_area.DownloadAddr, SE_FW_HEADER_TOT_LEN);
/* Ask for installation at next reset */
(void)FwUpdateAgentInstallAtNextReset((uint8_t *) fw_header_dwl_slot);
/* System Reboot*/
NVIC_SystemReset();
}
if (ret != HAL_OK)
{
MW_LOG(TS_OFF, VLEVEL_M, " -- Operation Failed \r\n");
}
}
static uint32_t FwUpdateAgentGetDownloadAreaInfo(FwImageFlashTypeDef *pArea)
{
uint32_t ret;
if (pArea != NULL)
{
pArea->DownloadAddr = SFU_IMG_SLOT_DWL_REGION_BEGIN_VALUE;
pArea->MaxSizeInBytes = (uint32_t)SFU_IMG_SLOT_DWL_REGION_SIZE;
pArea->ImageOffsetInBytes = SFU_IMG_IMAGE_OFFSET;
ret = HAL_OK;
}
else
{
ret = HAL_ERROR;
}
return ret;
}
static uint32_t FwUpdateAgentInstallAtNextReset(uint8_t *pfw_header)
{
uint32_t ret = HAL_OK;
if (pfw_header == NULL)
{
return HAL_ERROR;
}
ret = FLASH_Erase((void *) SFU_IMG_SWAP_REGION_BEGIN_VALUE, SFU_IMG_IMAGE_OFFSET);
if (ret == HAL_OK)
{
ret = FLASH_Write(SFU_IMG_SWAP_REGION_BEGIN_VALUE, pfw_header, SE_FW_HEADER_TOT_LEN);
}
return ret;
}
#endif /* INTEROP_TEST_MODE == 0 */
Reference in New Issue View Git Blame Copy Permalink