andy/kunlun
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3cfec2f3eb8bf953f8da432bc19f14d2221235d2
kunlun/app/smart_grid/sta/iot_sg_sta_cfg_flash.c
andy c756587541 初始提交
2024-09-28 14:24:04 +08:00

1365 lines
40 KiB
C
Raw Blame History

/****************************************************************************
Copyright(c) 2019 by Aerospace C.Power (Chongqing) Microelectronics. ALL RIGHTS RESERVED.
This Information is proprietary to Aerospace C.Power (Chongqing) Microelectronics and MAY NOT
be copied by any method or incorporated into another program without
the express written consent of Aerospace C.Power. This Information or any portion
thereof remains the property of Aerospace C.Power. The Information contained herein
is believed to be accurate and Aerospace C.Power assumes no responsibility or
liability for its use in any way and conveys no license or title under
any patent or copyright and makes no representation or warranty that this
Information is free from patent or copyright infringement.
****************************************************************************/
/* os_shim header files */
#include "os_types_api.h"
#include "os_timer_api.h"
#include "os_utils_api.h"
/* iot common header files */
#include "iot_errno_api.h"
#include "iot_dbglog_api.h"
#include "iot_io_api.h"
#include "iot_crc_api.h"
#include "iot_oem_api.h"
/* smart grid internal header files */
#include "iot_sg_fr.h"
#include "iot_sg.h"
#include "iot_sg_flash.h"
#include "iot_sg_sta_cfg_flash.h"
#if (IOT_SMART_GRID_FLASH_ENABLE)
/* defines the sg app sta flash config storage mode used to JIANGSU */
#define IOT_SG_STA_FLASH_CFG_SM_JS (0)
/* defines the sg app sta flash config storage mode used to FUJIAN */
#define IOT_SG_STA_FLASH_CFG_SM_FJ (1)
/* defines the sg app sta flash config storage mode used to NW */
#define IOT_SG_STA_FLASH_CFG_SM_NW (2)
/* defines the sg app sta flash config storage mode number */
#define IOT_SG_STA_METER_CFG_NUM (0xA001)
static const iot_sg_sta_flash_cfg_storage_mode_t flash_cfg_mode_list[ \
IOT_SG_STA_FLASH_CFG_MODE_CNT] = {
{
.total_size = (IOT_SG_STA_MODULAR_CFG_LEN * 10),
.data = {
{
.offset = IOT_SG_STA_MODULAR_CFG_START_OFFSET,
.len = IOT_SG_STA_CFG_TYPE_JS_3P_1MIN_CURVE_MAX_LEN,
},
{
.offset = IOT_SG_STA_MODULAR_CFG_START_OFFSET +
IOT_SG_STA_MODULAR_CFG_LEN,
.len = IOT_SG_STA_CFG_TYPE_JS_3P_DF_MAX_LEN,
},
{
.offset = (IOT_SG_STA_MODULAR_CFG_START_OFFSET +
IOT_SG_STA_MODULAR_CFG_LEN * 2),
.len = IOT_SG_STA_CFG_TYPE_JS_3P_MF_MAX_LEN,
},
{
.offset = (IOT_SG_STA_MODULAR_CFG_START_OFFSET +
IOT_SG_STA_MODULAR_CFG_LEN * 3),
.len = IOT_SG_STA_CFG_TYPE_JS_3P_15MIN_CURVE_MAX_LEN,
},
{
.offset = (IOT_SG_STA_MODULAR_CFG_START_OFFSET +
IOT_SG_STA_MODULAR_CFG_LEN * 4),
.len = IOT_SG_STA_CFG_TYPE_JS_1MIN_CURVE_MAX_LEN,
},
{
.offset = (IOT_SG_STA_MODULAR_CFG_START_OFFSET +
IOT_SG_STA_MODULAR_CFG_LEN * 5),
.len = IOT_SG_STA_CFG_TYPE_JS_DF_MAX_LEN,
},
{
.offset = (IOT_SG_STA_MODULAR_CFG_START_OFFSET +
IOT_SG_STA_MODULAR_CFG_LEN * 6),
.len = IOT_SG_STA_CFG_TYPE_JS_MF_MAX_LEN,
},
{
.offset = (IOT_SG_STA_MODULAR_CFG_START_OFFSET +
IOT_SG_STA_MODULAR_CFG_LEN * 7),
.len = IOT_SG_STA_CFG_TYPE_JS_15MIN_CURVE_MAX_LEN,
},
{
.offset = (IOT_SG_STA_MODULAR_CFG_START_OFFSET +
IOT_SG_STA_MODULAR_CFG_LEN * 8),
.len = IOT_SG_STA_CFG_TYPE_JS_3P_DC_MAX_LEN,
},
{
.offset = (IOT_SG_STA_MODULAR_CFG_START_OFFSET +
IOT_SG_STA_MODULAR_CFG_LEN * 9),
.len = IOT_SG_STA_CFG_TYPE_JS_DC_MAX_LEN,
},
},
},
{
.total_size = IOT_SG_STA_MODULAR_CFG_LEN * 6,
.data = {
{
.offset = IOT_SG_STA_MODULAR_CFG_START_OFFSET,
.len = IOT_SG_STA_CFG_TYPE_FJ_TM_CFG_INFO_MAX_LEN,
},
{
.offset = (IOT_SG_STA_MODULAR_CFG_START_OFFSET +
IOT_SG_STA_MODULAR_CFG_LEN * 3),
.len = IOT_SG_STA_CFG_TYPE_FJ_EVT_RPT_MAX_LEN,
},
{
.offset = (IOT_SG_STA_MODULAR_CFG_START_OFFSET +
IOT_SG_STA_MODULAR_CFG_LEN * 4),
.len = IOT_SG_STA_CFG_TYPE_FJ_PWR_REC_MAX_LEN,
},
{
.offset = (IOT_SG_STA_MODULAR_CFG_START_OFFSET +
IOT_SG_STA_MODULAR_CFG_LEN * 5),
.len = IOT_SG_STA_CFG_TYPE_FJ_TASK_COMM_CFG_MAX_LEN,
},
},
},
#if IOT_SMART_GRID_EDGE_COMPUTING_ENABLE
{
.total_size = IOT_SG_STA_MODULAR_CFG_LEN * 3,
.data = {
{
.offset = IOT_SG_STA_MODULAR_CFG_START_OFFSET,
.len = IOT_SG_STA_CFG_TYPE_NW_TASK_CFG_MAX_LEN,
},
{
.offset = (IOT_SG_STA_MODULAR_CFG_START_OFFSET +
IOT_SG_STA_MODULAR_CFG_LEN),
.len = IOT_SG_STA_CFG_TYPE_NW_TASK_CFG_MAX_LEN,
},
{
.offset = (IOT_SG_STA_MODULAR_CFG_START_OFFSET +
IOT_SG_STA_MODULAR_CFG_LEN * 2),
.len = IOT_SG_STA_CFG_TYPE_NW_EDGE_COMPUTING_CFG_MAX_LEN,
},
},
},
#else
{
.total_size = IOT_SG_STA_MODULAR_CFG_LEN * 2,
.data = {
{
.offset = IOT_SG_STA_MODULAR_CFG_START_OFFSET,
.len = IOT_SG_STA_CFG_TYPE_NW_TASK_CFG_MAX_LEN,
},
{
.offset = (IOT_SG_STA_MODULAR_CFG_START_OFFSET +
IOT_SG_STA_MODULAR_CFG_LEN),
.len = IOT_SG_STA_CFG_TYPE_NW_TASK_CFG_MAX_LEN,
},
},
},
#endif
};
#if IOT_SMART_GRID_EXT_FJ_FUNC_ENABLE
/* compare ct_rec2 with ct_rec1, whose record time is the latest
* 1 - ct_rec2 time is the latest, or equal to ct_rec1 time
* 0 - otherwise
*/
static uint32_t iot_sg_sta_flash_fj_ct_rec_cmp(
iot_sg_sta_flash_fj_ct_rec_t *ct_rec1,
iot_sg_sta_flash_fj_ct_rec_t *ct_rec2)
{
int64_t delta;
iot_time_tm_t tm1, tm2;
tm1.tm_year = (uint16_t)ct_rec1->year + 2000;
tm1.tm_mon = (uint8_t)ct_rec1->month;
tm1.tm_mday = (uint8_t)ct_rec1->day;
tm1.tm_hour = (uint8_t)ct_rec1->hour;
tm1.tm_min = (uint8_t)ct_rec1->minute;
tm1.tm_sec = (uint8_t)ct_rec1->second;
tm2.tm_year = (uint16_t)ct_rec2->year + 2000;
tm2.tm_mon = (uint8_t)ct_rec2->month;
tm2.tm_mday = (uint8_t)ct_rec2->day;
tm2.tm_hour = (uint8_t)ct_rec2->hour;
tm2.tm_min = (uint8_t)ct_rec2->minute;
tm2.tm_sec = (uint8_t)ct_rec2->second;
delta = iot_rtc_delta_calc(&tm1, &tm2);
if (delta < 0) {
return 0;
}
return 1;
}
/* get correct time record of specified index for FJ
* ERR_OK - get correct time record success
* ERR_FAIL - otherwise
*/
static uint32_t iot_sg_sta_flash_fj_ct_rec_get(
iot_sg_sta_flash_fj_ct_rec_t *ct_rec, uint16_t index)
{
uint32_t data_offset, ret = ERR_OK, crc;
iot_sg_sta_flash_cfg_info_t *cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en) {
ret = ERR_FAIL;
goto out;
}
if (ct_rec == NULL) {
ret = ERR_FAIL;
goto out;
}
if (index >= IOT_SG_STA_FLASH_FJ_CT_REC_MAX_CNT) {
ret = ERR_FAIL;
goto out;
}
data_offset =
cfg_info->flash_cfg_mode->data[IOT_SG_STA_FJ_TM_CFG_TYPE].offset +
sizeof(iot_sg_sta_flash_fj_ct_cfg_t) +
index * sizeof(iot_sg_sta_flash_fj_ct_rec_t);
IOT_ASSERT(sizeof(*ct_rec) <=
cfg_info->flash_cfg_mode->data[IOT_SG_STA_FJ_TM_CFG_TYPE].len);
ret = iot_sg_flash_read(data_offset, sizeof(*ct_rec), (uint8_t *)ct_rec);
if (ret != ERR_OK) {
ret = ERR_FAIL;
goto out;
}
crc =
iot_getcrc32((uint8_t*)ct_rec, sizeof(*ct_rec) - sizeof(ct_rec->crc));
if (crc != ct_rec->crc) {
ret = ERR_FAIL;
goto out;
}
out:
return ret;
}
/* find the latest correct time record index for FJ
* ERR_OK - successfully find latest correct time record index
* ERR_FAIL - no exsit correct time record in flash
*/
static uint32_t iot_sg_sta_flash_fj_latest_index_find(uint16_t *index)
{
uint8_t rec_exist = 0;
uint16_t i;
iot_sg_sta_flash_fj_ct_rec_t ct_rec_latest, ct_rec_tmp;
for (i = 0; i < IOT_SG_STA_FLASH_FJ_CT_REC_MAX_CNT; i++) {
if (iot_sg_sta_flash_fj_ct_rec_get(&ct_rec_tmp, i) != ERR_OK) {
continue;
}
if (!rec_exist) {
rec_exist = 1;
*index = i;
os_mem_cpy(&ct_rec_latest, &ct_rec_tmp,
sizeof(iot_sg_sta_flash_fj_ct_rec_t));
} else {
if (!iot_sg_sta_flash_fj_ct_rec_cmp(&ct_rec_tmp, &ct_rec_latest)) {
*index = i;
os_mem_cpy(&ct_rec_latest, &ct_rec_tmp,
sizeof(iot_sg_sta_flash_fj_ct_rec_t));
}
}
}
if (!rec_exist) {
return ERR_FAIL;
}
return ERR_OK;
}
/**
* @brief get power on/off record of specified index for FJ
* @param pwr_rec power on/off record of specified index
* @param index the specified index
* @retval ERR_OK - get power on/off record success
* ERR_FAIL - otherwise
*/
static uint32_t iot_sg_sta_flash_fj_pwr_rec_get(
iot_sg_sta_flash_fj_pwr_rec_t *pwr_rec, uint8_t index)
{
uint32_t data_offset, ret = ERR_OK, crc;
iot_sg_sta_flash_cfg_info_t *cfg_info = &p_sg_glb->desc.sta->flash_cfg_info;
const iot_sg_sta_flash_cfg_data_desc_t *data_desc;
if (!cfg_info->flash_cfg_en) {
ret = ERR_FAIL;
goto out;
}
if (pwr_rec == NULL) {
ret = ERR_FAIL;
goto out;
}
if (index >= IOT_SG_STA_FLASH_FJ_POWER_RECORD_CNT_MAX) {
ret = ERR_FAIL;
goto out;
}
data_desc = &cfg_info->flash_cfg_mode->data[IOT_SG_STA_FJ_PWR_REC_CFG_TYPE];
data_offset = data_desc->offset + sizeof(iot_sg_sta_flash_fj_pwr_rpt_cfg_t)
+ index * sizeof(*pwr_rec);
IOT_ASSERT(sizeof(*pwr_rec) <= data_desc->len);
ret = iot_sg_flash_read(data_offset, sizeof(*pwr_rec), (uint8_t *)pwr_rec);
if (ret != ERR_OK) {
ret = ERR_FAIL;
goto out;
}
crc = iot_getcrc32((uint8_t *)pwr_rec, sizeof(*pwr_rec) -
sizeof(pwr_rec->crc));
if (crc != pwr_rec->crc) {
ret = ERR_FAIL;
goto out;
}
out:
return ret;
}
/**
* @brief find the latest power on/off record index and sequence for FJ
* @param index the index of the latest power on/off record
* @param sn the sequence of the latest power on/off record
* @retval ERR_OK - successfully find latest power on/off record index
* ERR_FAIL - no exsit power on/off record in flash
*/
static uint32_t iot_sg_sta_flash_fj_pwr_rec_latest_find(uint8_t *index,
uint32_t *sn)
{
uint8_t rec_exist = 0, i;
iot_sg_sta_flash_fj_pwr_rec_t pwr_rec_tmp;
for (i = 0; i < IOT_SG_STA_FLASH_FJ_POWER_RECORD_CNT_MAX; i++) {
if (iot_sg_sta_flash_fj_pwr_rec_get(&pwr_rec_tmp, i) != ERR_OK) {
continue;
}
if (!rec_exist) {
rec_exist = 1;
*index = i;
*sn = pwr_rec_tmp.sn;
} else if (*sn <= pwr_rec_tmp.sn) {
*index = i;
*sn = pwr_rec_tmp.sn;
}
}
if (!rec_exist) {
return ERR_FAIL;
}
return ERR_OK;
}
uint32_t iot_sg_sta_flash_fj_ct_cfg_save(iot_sg_sta_flash_fj_ct_cfg_t *ct_cfg)
{
uint32_t cfg_offset = 0, ret = ERR_OK;
iot_sg_sta_flash_cfg_info_t *cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en) {
ret = ERR_FAIL;
goto out;
}
if (ct_cfg == NULL) {
ret = ERR_FAIL;
goto out;
}
cfg_offset =
cfg_info->flash_cfg_mode->data[IOT_SG_STA_FJ_TM_CFG_TYPE].offset;
ct_cfg->crc =
iot_getcrc32((uint8_t*)ct_cfg, sizeof(*ct_cfg) - sizeof(ct_cfg->crc));
ret = iot_sg_flash_write(cfg_offset, sizeof(*ct_cfg), (uint8_t *)ct_cfg);
out:
return ret;
}
uint32_t iot_sg_sta_flash_fj_ct_rec_save(iot_sg_sta_flash_fj_ct_rec_t *ct_rec)
{
uint16_t write_idx;
uint32_t cfg_offset = 0, ret = ERR_OK;
iot_sg_sta_flash_cfg_info_t *cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
write_idx = cfg_info->fj_ct_idx + 1;
if (!cfg_info->flash_cfg_en) {
ret = ERR_FAIL;
goto out;
}
if (ct_rec == NULL) {
ret = ERR_FAIL;
goto out;
}
if (write_idx >= IOT_SG_STA_FLASH_FJ_CT_REC_MAX_CNT) {
write_idx = 0;
}
cfg_offset =
cfg_info->flash_cfg_mode->data[IOT_SG_STA_FJ_TM_CFG_TYPE].offset +
sizeof(iot_sg_sta_flash_fj_ct_cfg_t) +
write_idx * sizeof(iot_sg_sta_flash_fj_ct_rec_t);
ct_rec->crc =
iot_getcrc32((uint8_t*)ct_rec, sizeof(*ct_rec) - sizeof(ct_rec->crc));
ret = iot_sg_flash_write(cfg_offset, sizeof(*ct_rec), (uint8_t *)ct_rec);
if (ret == ERR_OK) {
cfg_info->fj_ct_idx = write_idx;
}
out:
return ret;
}
uint32_t iot_sg_sta_flash_fj_ct_cfg_get(iot_sg_sta_flash_fj_ct_cfg_t *ct_cfg)
{
uint32_t data_offset, ret = ERR_OK, crc;
iot_sg_sta_flash_cfg_info_t *cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en) {
ret = ERR_FAIL;
goto out;
}
if (ct_cfg == NULL) {
ret = ERR_FAIL;
goto out;
}
data_offset =
cfg_info->flash_cfg_mode->data[IOT_SG_STA_FJ_TM_CFG_TYPE].offset;
IOT_ASSERT(sizeof(*ct_cfg) <=
cfg_info->flash_cfg_mode->data[IOT_SG_STA_FJ_TM_CFG_TYPE].len);
ret = iot_sg_flash_read(data_offset, sizeof(*ct_cfg), (uint8_t *)ct_cfg);
if (ret != ERR_OK) {
ret = ERR_FAIL;
goto out;
}
crc =
iot_getcrc32((uint8_t*)ct_cfg, sizeof(*ct_cfg) - sizeof(ct_cfg->crc));
if (crc != ct_cfg->crc) {
ret = ERR_FAIL;
goto out;
}
out:
return ret;
}
uint32_t iot_sg_sta_flash_fj_latest_ct_rec_get(
iot_sg_sta_flash_fj_ct_rec_t *ct_rec)
{
iot_sg_sta_flash_cfg_info_t *cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
if (iot_sg_sta_flash_fj_ct_rec_get(
ct_rec, cfg_info->fj_ct_idx) != ERR_OK) {
return ERR_FAIL;
}
return ERR_OK;
}
uint32_t iot_sg_sta_flash_fj_evt_rpt_cfg_save(
iot_sg_sta_flash_fj_evt_rpt_cfg_t *cfg)
{
uint32_t cfg_type;
uint32_t cfg_offset = 0, ret = ERR_OK;
iot_sg_sta_flash_cfg_info_t *cfg_info = &p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en || !cfg) {
ret = ERR_FAIL;
goto out;
}
cfg_type = IOT_SG_STA_FJ_EVT_RPT_CFG_TYPE;
cfg_offset = cfg_info->flash_cfg_mode->data[cfg_type].offset;
cfg->crc = iot_getcrc32((uint8_t *)cfg, sizeof(*cfg) - sizeof(cfg->crc));
ret = iot_sg_flash_write(cfg_offset, sizeof(*cfg), (uint8_t *)cfg);
out:
return ret;
}
uint32_t iot_sg_sta_flash_fj_evt_rpt_cfg_get(
iot_sg_sta_flash_fj_evt_rpt_cfg_t *cfg)
{
uint8_t cfg_type;
uint32_t data_offset, ret = ERR_FAIL, crc;
iot_sg_sta_flash_cfg_info_t *cfg_info = &p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en || !cfg) {
goto out;
}
cfg_type = IOT_SG_STA_FJ_EVT_RPT_CFG_TYPE;
data_offset = cfg_info->flash_cfg_mode->data[cfg_type].offset;
IOT_ASSERT(sizeof(*cfg) <= cfg_info->flash_cfg_mode->data[cfg_type].len);
ret = iot_sg_flash_read(data_offset, sizeof(*cfg), (uint8_t *)cfg);
if (ret != ERR_OK) {
goto out;
}
crc = iot_getcrc32((uint8_t *)cfg, sizeof(*cfg) - sizeof(crc));
if (crc != cfg->crc) {
ret = ERR_FAIL;
}
out:
return ret;
}
uint32_t iot_sg_sta_flash_fj_pwr_rpt_cfg_save(
iot_sg_sta_flash_fj_pwr_rpt_cfg_t *cfg)
{
uint32_t cfg_offset, ret = ERR_FAIL;
uint8_t cfg_type;
iot_sg_sta_flash_cfg_info_t *cfg_info = &p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en || !cfg) {
goto out;
}
cfg_type = IOT_SG_STA_FJ_PWR_REC_CFG_TYPE;
cfg_offset = cfg_info->flash_cfg_mode->data[cfg_type].offset;
cfg->crc = iot_getcrc32((uint8_t *)cfg, sizeof(*cfg) - sizeof(cfg->crc));
ret = iot_sg_flash_write(cfg_offset, sizeof(*cfg), (uint8_t *)cfg);
out:
return ret;
}
uint32_t iot_sg_sta_flash_fj_pwr_rpt_cfg_get(
iot_sg_sta_flash_fj_pwr_rpt_cfg_t *cfg)
{
uint32_t data_offset, ret = ERR_FAIL, crc;
uint8_t cfg_type;
iot_sg_sta_flash_cfg_info_t *cfg_info = &p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en || !cfg) {
goto out;
}
cfg_type = IOT_SG_STA_FJ_PWR_REC_CFG_TYPE;
data_offset = cfg_info->flash_cfg_mode->data[cfg_type].offset;
IOT_ASSERT(sizeof(*cfg) <= cfg_info->flash_cfg_mode->data[cfg_type].len);
ret = iot_sg_flash_read(data_offset, sizeof(*cfg), (uint8_t *)cfg);
if (ret != ERR_OK) {
goto out;
}
crc = iot_getcrc32((uint8_t *)cfg, sizeof(*cfg) - sizeof(cfg->crc));
if (crc != cfg->crc) {
ret = ERR_FAIL;
}
out:
return ret;
}
uint32_t iot_sg_sta_flash_fj_pwr_record_get(
iot_sg_sta_flash_fj_pwr_rec_t *record, uint8_t last_index)
{
uint8_t index = 0;
uint32_t ret = ERR_FAIL;
iot_sg_sta_flash_cfg_info_t *cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
if (!last_index || last_index > IOT_SG_STA_FLASH_FJ_POWER_RECORD_CNT_MAX) {
goto out;
}
if (!cfg_info->fj_pwr_rec_sn || cfg_info->fj_pwr_rec_sn < last_index) {
goto out;
}
if ((cfg_info->fj_pwr_rec_idx + 1) >= last_index) {
index = cfg_info->fj_pwr_rec_idx - last_index + 1;
} else {
index = IOT_SG_STA_FLASH_FJ_POWER_RECORD_CNT_MAX - last_index +
cfg_info->fj_pwr_rec_idx + 1;
}
ret = iot_sg_sta_flash_fj_pwr_rec_get(record, index);
out:
return ret;
}
uint32_t iot_sg_sta_flash_fj_pwr_record_save(
iot_sg_sta_flash_fj_pwr_rec_t *record, uint8_t is_overlast)
{
uint8_t cfg_type, write_idx;
uint32_t cfg_offset = 0, ret = ERR_FAIL;
iot_sg_sta_flash_cfg_info_t *cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en || !record) {
goto out;
}
write_idx = cfg_info->fj_pwr_rec_idx;
record->sn = cfg_info->fj_pwr_rec_sn;
if (!is_overlast) {
write_idx++;
record->sn++;
if (write_idx >= IOT_SG_STA_FLASH_FJ_POWER_RECORD_CNT_MAX) {
write_idx = 0;
}
}
cfg_type = IOT_SG_STA_FJ_PWR_REC_CFG_TYPE;
cfg_offset = cfg_info->flash_cfg_mode->data[cfg_type].offset +
sizeof(iot_sg_sta_flash_fj_pwr_rpt_cfg_t) + write_idx * sizeof(*record);
record->crc = iot_getcrc32((uint8_t*)record, sizeof(*record) -
sizeof(record->crc));
ret = iot_sg_flash_write(cfg_offset, sizeof(*record), (uint8_t *)record);
if (!is_overlast && ret == ERR_OK) {
cfg_info->fj_pwr_rec_idx = write_idx;
cfg_info->fj_pwr_rec_sn = record->sn;
}
out:
return ret;
}
uint32_t iot_sg_sta_flash_fj_pwr_record_clear()
{
uint8_t cfg_type, *data;
uint32_t cfg_offset = 0, size, ret;
iot_sg_sta_flash_cfg_info_t *cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
iot_pkt_t *pkt_buff = NULL;
if (!cfg_info->flash_cfg_en) {
ret = ERR_NOT_READY;
goto out;
}
size = IOT_SG_STA_FLASH_FJ_POWER_RECORD_CNT_MAX *
sizeof(iot_sg_sta_flash_fj_pwr_rec_t);
pkt_buff = iot_pkt_alloc(size, IOT_SMART_GRID_MID);
if (!pkt_buff) {
ret = ERR_NOMEM;
goto out;
}
data = iot_pkt_put(pkt_buff, size);
os_mem_set(data, 0x0, size);
cfg_type = IOT_SG_STA_FJ_PWR_REC_CFG_TYPE;
cfg_offset = cfg_info->flash_cfg_mode->data[cfg_type].offset +
sizeof(iot_sg_sta_flash_fj_pwr_rpt_cfg_t);
ret = iot_sg_flash_write(cfg_offset, size, data);
out:
if (ret) {
iot_sg_printf("%s fail %lu\n", __FUNCTION__, ret);
} else {
cfg_info->fj_pwr_rec_idx = 0;
cfg_info->fj_pwr_rec_sn = 0;
}
if (pkt_buff) {
iot_pkt_free(pkt_buff);
}
return ret;
}
uint32_t iot_sg_sta_flash_fj_task_comm_cfg_save(
iot_sg_sta_flash_fj_task_comm_cfg_t *cfg)
{
uint32_t cfg_type;
uint32_t cfg_offset = 0, ret = ERR_OK;
iot_sg_sta_flash_cfg_info_t *cfg_info = &p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en || !cfg) {
ret = ERR_FAIL;
goto out;
}
cfg_type = IOT_SG_STA_FJ_TASK_COMM_CFG_TYPE;
cfg->mark_magic = IOT_SG_STA_FLASH_FJ_TASK_COMM_MAGIC_MARK;
cfg_offset = cfg_info->flash_cfg_mode->data[cfg_type].offset;
cfg->crc = iot_getcrc32((uint8_t *)cfg, sizeof(*cfg) - sizeof(cfg->crc));
ret = iot_sg_flash_write(cfg_offset, sizeof(*cfg), (uint8_t *)cfg);
out:
return ret;
}
uint32_t iot_sg_sta_flash_fj_task_comm_cfg_get(
iot_sg_sta_flash_fj_task_comm_cfg_t *cfg)
{
uint8_t cfg_type;
uint32_t data_offset, ret = ERR_FAIL, crc;
iot_sg_sta_flash_cfg_info_t *cfg_info = &p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en || !cfg) {
goto out;
}
cfg_type = IOT_SG_STA_FJ_TASK_COMM_CFG_TYPE;
data_offset = cfg_info->flash_cfg_mode->data[cfg_type].offset;
IOT_ASSERT(sizeof(*cfg) <= cfg_info->flash_cfg_mode->data[cfg_type].len);
ret = iot_sg_flash_read(data_offset, sizeof(*cfg), (uint8_t*)cfg);
if (ret != ERR_OK) {
goto out;
}
if (cfg->mark_magic != IOT_SG_STA_FLASH_FJ_TASK_COMM_MAGIC_MARK) {
ret = ERR_FAIL;
goto out;
}
crc = iot_getcrc32((uint8_t *)cfg, sizeof(*cfg) - sizeof(crc));
if (crc != cfg->crc) {
ret = ERR_FAIL;
}
out:
return ret;
}
#else /* IOT_SMART_GRID_EXT_FJ_FUNC_ENABLE */
uint32_t iot_sg_sta_flash_fj_ct_rec_save(iot_sg_sta_flash_fj_ct_rec_t *ct_rec)
{
(void)ct_rec;
return ERR_NOSUPP;
}
#endif /* IOT_SMART_GRID_EXT_FJ_FUNC_ENABLE */
uint32_t iot_sg_sta_flash_cfg_init()
{
uint32_t ret = ERR_OK, dev_type, flash_size = 0;
uint8_t user_type = iot_sg_sta_get_user_type();
iot_sg_sta_flash_cfg_info_t *flash_cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
iot_sg_sta_global_t *sta_glb = p_sg_glb->desc.sta;
if (flash_cfg_info->flash_cfg_en) {
goto out;
}
if (!sta_glb->drv) {
ret = ERR_NOSUPP;
goto out;
}
dev_type = (uint8_t)sta_glb->drv->get_device_type();
/* NOTE: if there are more protocols to support, you can expand here.
* exchange to switch case statement.
*/
switch (dev_type) {
case IOT_SG_STA_DEV_TYPE_COLLECTOR_T2:
case IOT_SG_STA_DEV_TYPE_POWER_METER:
{
switch (user_type) {
case USER_TYPE_STATE_GRID_JIANGSU:
{
flash_cfg_info->flash_cfg_mode =
&flash_cfg_mode_list[IOT_SG_STA_FLASH_CFG_SM_JS];
break;
}
case USER_TYPE_STATE_GRID_FUJIAN:
{
flash_cfg_info->flash_cfg_mode =
&flash_cfg_mode_list[IOT_SG_STA_FLASH_CFG_SM_FJ];
break;
}
default:
if (sta_glb->proto == IOT_SG_STA_APP_PROTO_NW) {
flash_cfg_info->flash_cfg_mode =
&flash_cfg_mode_list[IOT_SG_STA_FLASH_CFG_SM_NW];
} else {
goto out;
}
break;
}
break;
}
case IOT_SG_STA_DEV_TYPE_COLLECTOR_T3:
{
if (sta_glb->proto == IOT_SG_STA_APP_PROTO_NW) {
flash_cfg_info->flash_cfg_mode =
&flash_cfg_mode_list[IOT_SG_STA_FLASH_CFG_SM_NW];
} else {
goto out;
}
break;
}
case IOT_SG_STA_DEV_TYPE_COLLECTOR_T1:
{
if (sta_glb->proto == IOT_SG_STA_APP_PROTO_NW) {
flash_cfg_info->flash_cfg_mode =
&flash_cfg_mode_list[IOT_SG_STA_FLASH_CFG_SM_NW];
} else {
goto out;
}
break;
}
default:
goto out;
}
flash_size = iot_sg_flash_init();
if (flash_size < flash_cfg_info->flash_cfg_mode->total_size) {
ret = ERR_NOSUPP;
goto out;
}
flash_cfg_info->flash_cfg_en = 1;
#if IOT_SMART_GRID_EXT_FJ_FUNC_ENABLE
uint32_t fj_pwr_rec_sn = 0;
uint8_t fj_pwr_rec_idx = 0;
if (user_type == USER_TYPE_STATE_GRID_FUJIAN) {
if (iot_sg_sta_flash_fj_latest_index_find(
&(flash_cfg_info->fj_ct_idx)) != ERR_OK) {
flash_cfg_info->fj_ct_idx = 0;
}
if (iot_sg_sta_flash_fj_pwr_rec_latest_find(
&fj_pwr_rec_idx, &fj_pwr_rec_sn) != ERR_OK) {
fj_pwr_rec_idx = 0;
fj_pwr_rec_sn = 0;
}
flash_cfg_info->fj_pwr_rec_idx = fj_pwr_rec_idx;
flash_cfg_info->fj_pwr_rec_sn = fj_pwr_rec_sn;
}
#endif
out:
return ret;
}
uint32_t iot_sg_sta_flash_tsfm_record_init()
{
uint8_t i;
uint32_t ret = ERR_FAIL, flash_size;
uint32_t offset = IOT_SG_STA_MODULAR_CFG_START_OFFSET;
iot_sg_sta_flash_cfg_info_t *flash_cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
iot_sg_sta_global_t *sta_glb = p_sg_glb->desc.sta;
if (flash_cfg_info->flash_record_en) {
ret = ERR_OK;
goto out;
}
if (!sta_glb->br2_enable) {
goto out;
}
flash_size = iot_sg_flash_init();
if (flash_cfg_info->flash_cfg_en) {
offset = flash_cfg_info->flash_cfg_mode->total_size;
flash_size -= flash_cfg_info->flash_cfg_mode->total_size;
}
flash_cfg_info->flash_record.total_size =
IOT_SG_STA_MODULAR_CFG_LEN * IOT_SG_STA_METER_RECORD_TYPE_CNT;
if (flash_size < flash_cfg_info->flash_record.total_size) {
goto out;
}
for (i = 0; i < IOT_SG_STA_METER_RECORD_TYPE_CNT; i++) {
flash_cfg_info->flash_record.data[i].len =
IOT_SG_STA_CFG_TYPE_TSFM_TOPO_RECORD_MAX_LEN;
flash_cfg_info->flash_record.data[i].offset = offset;
offset += IOT_SG_STA_MODULAR_CFG_LEN;
}
flash_cfg_info->flash_record_en = 1;
ret = ERR_OK;
out:
return ret;
}
uint32_t iot_sg_sta_flash_cfg_get_cfg_len()
{
uint32_t cfg_len = 0, record_len = 0;
iot_sg_sta_flash_cfg_info_t *flash_cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
if (flash_cfg_info->flash_cfg_en) {
cfg_len += flash_cfg_info->flash_cfg_mode->total_size;
IOT_ASSERT(cfg_len);
}
if (flash_cfg_info->flash_record_en) {
record_len += flash_cfg_info->flash_record.total_size;
IOT_ASSERT(record_len);
}
return cfg_len + record_len;
}
uint32_t iot_sg_sta_flash_js_task_cfg_get_by_type(uint8_t task_type,
iot_sg_meter_js_task_config_hdr_t *cfg)
{
uint32_t data_offset, ret = ERR_FAIL, crc;
iot_sg_sta_flash_cfg_info_t *cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en) {
goto out;
}
if (task_type >= IOT_SG_STA_FLASH_CFG_DATA_MAX_CNT) {
goto out;
}
data_offset = cfg_info->flash_cfg_mode->data[task_type].offset;
IOT_ASSERT(sizeof(*cfg) <= cfg_info->flash_cfg_mode->data[task_type].len);
ret = iot_sg_flash_read(data_offset, sizeof(*cfg), (uint8_t *)cfg);
if (ret != ERR_OK) {
goto out;
}
crc = iot_getcrc32((uint8_t*)cfg, sizeof(*cfg) - sizeof(cfg->crc));
if (crc != cfg->crc) {
ret = ERR_FAIL;
goto out;
}
out:
return ret;
}
uint32_t iot_sg_sta_flash_js_task_cfg_get_by_id(uint8_t id,
iot_sg_meter_js_task_config_hdr_t *cfg)
{
uint32_t data_offset, ret = ERR_FAIL, crc;
iot_sg_sta_flash_cfg_info_t *cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en) {
goto out;
}
for (uint8_t i = 0; i < IOT_SG_STA_FLASH_CFG_DATA_MAX_CNT; i++) {
data_offset = cfg_info->flash_cfg_mode->data[i].offset;
IOT_ASSERT(sizeof(*cfg) <= cfg_info->flash_cfg_mode->data[i].len);
ret = iot_sg_flash_read(data_offset, sizeof(*cfg), (uint8_t *)cfg);
if (ret != ERR_OK) {
continue;
}
crc = iot_getcrc32((uint8_t*)cfg, sizeof(*cfg) - sizeof(cfg->crc));
if (crc != cfg->crc) {
continue;
}
if (cfg->task_id == id) {
ret = ERR_OK;
goto out;
}
}
ret = ERR_FAIL;
out:
return ret;
}
uint32_t iot_sg_sta_flash_js_task_cfg_get_by_num(uint8_t num,
iot_sg_meter_js_task_config_hdr_t *cfg)
{
uint32_t data_offset, ret = ERR_FAIL, crc;
iot_sg_sta_flash_cfg_info_t *cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en) {
goto out;
}
for (uint8_t i = 0; i < IOT_SG_STA_FLASH_CFG_DATA_MAX_CNT; i++) {
data_offset = cfg_info->flash_cfg_mode->data[i].offset;
IOT_ASSERT(sizeof(*cfg) <= cfg_info->flash_cfg_mode->data[i].len);
ret = iot_sg_flash_read(data_offset, sizeof(*cfg), (uint8_t *)cfg);
if (ret != ERR_OK) {
continue;
}
crc = iot_getcrc32((uint8_t*)cfg, sizeof(*cfg) - sizeof(cfg->crc));
if (crc != cfg->crc) {
continue;
}
if (cfg->scheme_num == num) {
ret = ERR_OK;
goto out;
}
}
ret = ERR_FAIL;
out:
return ret;
}
uint32_t iot_sg_sta_flash_js_task_cfg_save(uint8_t task_type,
iot_sg_meter_js_task_config_hdr_t *cfg)
{
uint32_t cfg_offset = 0, ret = ERR_OK;
iot_sg_sta_flash_cfg_info_t *cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en) {
goto out;
}
if (cfg == NULL) {
ret = ERR_FAIL;
goto out;
}
if (task_type != cfg->task_type) {
ret = ERR_FAIL;
goto out;
}
if (task_type >= IOT_SG_STA_METER_JS_CFG_TYPE_MAX) {
ret = ERR_FAIL;
goto out;
}
cfg_offset = cfg_info->flash_cfg_mode->data[task_type].offset;
cfg->cfg_num = IOT_SG_STA_METER_CFG_NUM;
cfg->crc = iot_getcrc32((uint8_t*)cfg, sizeof(*cfg) - sizeof(cfg->crc));
ret = iot_sg_flash_write(cfg_offset,
sizeof(iot_sg_meter_js_task_config_hdr_t), (uint8_t *)cfg);
out:
return ret;
}
uint32_t iot_sg_sta_flash_tsfm_topo_record_get(
iot_sg_sta_flash_tsfm_topo_record_t *record)
{
uint8_t block_idx, unit_idx, first_flag = 1;
uint32_t data_offset, ret = ERR_FAIL, crc;
iot_sg_sta_flash_cfg_info_t *cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
iot_sg_sta_flash_tsfm_topo_record_block_t *record_block;
iot_pkt_t *pkt_buff = NULL;
if (!cfg_info->flash_record_en || !record) {
goto out;
}
pkt_buff = iot_pkt_alloc(sizeof(*record_block), IOT_SMART_GRID_MID);
if (!pkt_buff) {
ret = ERR_NOMEM;
goto out;
}
record_block = (iot_sg_sta_flash_tsfm_topo_record_block_t *)
iot_pkt_put(pkt_buff, sizeof(*record_block));
for (block_idx = 0; block_idx < IOT_SG_STA_METER_ZJ_CFG_LAUNCH_REC_BLOCK_MAX;
block_idx++) {
data_offset = cfg_info->flash_record.data[block_idx].offset;
IOT_ASSERT(sizeof(*record_block) <=
cfg_info->flash_record.data[block_idx].len);
if (iot_sg_flash_read(data_offset, sizeof(*record_block),
(uint8_t *)record_block) != ERR_OK) {
continue;
}
for (unit_idx = 0; unit_idx < IOT_SG_STA_METER_ZJ_CFG_BLOCK_UNIT_CNT;
unit_idx++) {
crc = iot_getcrc32((uint8_t*)&record_block->unit[unit_idx],
sizeof(record_block->unit[unit_idx]) - sizeof(crc));
if (crc != record_block->unit[unit_idx].crc) {
continue;
}
if (first_flag) {
*record = record_block->unit[unit_idx];
first_flag = 0;
} else {
if (record->flash_index <
record_block->unit[unit_idx].flash_index) {
*record = record_block->unit[unit_idx];
}
}
ret = ERR_OK;
}
}
out:
if (pkt_buff) {
iot_pkt_free(pkt_buff);
}
return ret;
}
uint32_t iot_sg_sta_flash_tsfm_topo_record_save(
iot_sg_sta_flash_tsfm_topo_record_t *record)
{
uint32_t unit_idx, block_idx;
uint32_t cfg_offset = 0, ret = ERR_OK;
iot_sg_sta_flash_cfg_info_t *cfg_info =
&p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_record_en) {
goto out;
}
if (record == NULL) {
ret = ERR_FAIL;
goto out;
}
unit_idx = record->flash_index % IOT_SG_STA_METER_ZJ_CFG_BLOCK_UNIT_CNT;
block_idx = (record->flash_index / IOT_SG_STA_METER_ZJ_CFG_BLOCK_UNIT_CNT)
% IOT_SG_STA_METER_ZJ_CFG_LAUNCH_REC_BLOCK_MAX;
BUILD_BUG_ON(IOT_SG_STA_METER_ZJ_CFG_BLOCK_UNIT_LEN == sizeof(*record));
cfg_offset = cfg_info->flash_record.data[block_idx].offset +
unit_idx * sizeof(*record);
record->crc = iot_getcrc32((uint8_t*)record,
sizeof(*record) - sizeof(record->crc));
ret = iot_sg_flash_write(cfg_offset, sizeof(*record), (uint8_t *)record);
out:
return ret;
}
uint32_t iot_sg_sta_flash_nw_task_cfg_save(
iot_sg_sta_flash_nw_task_cfg_info_t *cfg, uint8_t task_type)
{
uint32_t cfg_offset, ret = ERR_FAIL;
iot_sg_sta_flash_cfg_info_t *cfg_info = &p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en || !cfg) {
goto out;
}
if (task_type != IOT_SG_STA_METER_NW_CFG_SINGLE
&& task_type != IOT_SG_STA_METER_NW_CFG_3P) {
goto out;
}
cfg_offset = cfg_info->flash_cfg_mode->data[task_type].offset;
cfg->crc = iot_getcrc32((uint8_t *)cfg, sizeof(*cfg) - sizeof(cfg->crc));
ret = iot_sg_flash_write(cfg_offset, sizeof(*cfg), (uint8_t *)cfg);
out:
return ret;
}
uint32_t iot_sg_sta_flash_nw_task_cfg_get(
iot_sg_sta_flash_nw_task_cfg_info_t *cfg, uint8_t task_type, uint8_t *addr)
{
uint32_t data_offset, ret = ERR_FAIL, crc;
iot_sg_sta_global_t *sta_glb = p_sg_glb->desc.sta;
iot_sg_sta_flash_cfg_info_t *cfg_info = &p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en || !cfg) {
goto out;
}
if (task_type != IOT_SG_STA_METER_NW_CFG_SINGLE
&& task_type != IOT_SG_STA_METER_NW_CFG_3P) {
goto out;
}
data_offset = cfg_info->flash_cfg_mode->data[task_type].offset;
IOT_ASSERT(sizeof(*cfg) <= cfg_info->flash_cfg_mode->data[task_type].len);
ret = iot_sg_flash_read(data_offset, sizeof(*cfg), (uint8_t*)cfg);
if (ret != ERR_OK) {
goto out;
}
crc = iot_getcrc32((uint8_t *)cfg, sizeof(*cfg) - sizeof(crc));
if (crc != cfg->crc) {
ret = ERR_FAIL;
goto out;
}
if (sta_glb->drv->get_device_type() ==
IOT_SG_STA_DEV_TYPE_POWER_METER) {
if (!addr || !iot_mac_addr_valid(cfg->mac_addr)) {
goto out;
}
if (!iot_mac_addr_cmp(cfg->mac_addr, addr)) {
ret = ERR_FAIL;
}
}
out:
return ret;
}
#if IOT_SMART_GRID_EDGE_COMPUTING_ENABLE
uint32_t iot_sg_sta_flash_nw_edge_computing_cfg_get(
iot_sg_sta_flash_nw_edge_computing_cfg_info_t *cfg)
{
uint8_t cfg_type;
uint32_t data_offset, ret = ERR_FAIL, crc;
iot_sg_sta_flash_cfg_info_t *cfg_info = &p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en || !cfg) {
goto out;
}
cfg_type = IOT_SG_STA_NW_EDGE_COMPUTING_CFG_TYPE;
data_offset = cfg_info->flash_cfg_mode->data[cfg_type].offset;
IOT_ASSERT(sizeof(*cfg) <= cfg_info->flash_cfg_mode->data[cfg_type].len);
ret = iot_sg_flash_read(data_offset, sizeof(*cfg), (uint8_t *)cfg);
if (ret != ERR_OK) {
goto out;
}
crc = iot_getcrc32((uint8_t *)cfg, sizeof(*cfg) - sizeof(crc));
if (crc != cfg->crc) {
ret = ERR_FAIL;
}
out:
return ret;
}
uint32_t iot_sg_sta_flash_nw_edge_computing_cfg_save(
iot_sg_sta_flash_nw_edge_computing_cfg_info_t *cfg)
{
uint32_t cfg_offset, ret = ERR_FAIL;
iot_sg_sta_flash_cfg_info_t *cfg_info = &p_sg_glb->desc.sta->flash_cfg_info;
if (!cfg_info->flash_cfg_en || !cfg) {
goto out;
}
cfg_offset = cfg_info->flash_cfg_mode->data[
IOT_SG_STA_NW_EDGE_COMPUTING_CFG_TYPE].offset;
cfg->crc = iot_getcrc32((uint8_t *)cfg, sizeof(*cfg) - sizeof(cfg->crc));
ret = iot_sg_flash_write(cfg_offset, sizeof(*cfg), (uint8_t *)cfg);
out:
return ret;
}
#else
uint32_t iot_sg_sta_flash_nw_edge_computing_cfg_get(
iot_sg_sta_flash_nw_edge_computing_cfg_info_t *cfg)
{
(void)cfg;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_nw_edge_computing_cfg_save(
iot_sg_sta_flash_nw_edge_computing_cfg_info_t *cfg)
{
(void)cfg;
return ERR_NOSUPP;
}
#endif
#else /* IOT_SMART_GRID_FLASH_ENABLE */
uint32_t iot_sg_sta_flash_tsfm_record_init()
{
return ERR_OK;
}
uint32_t iot_sg_sta_flash_cfg_init()
{
return ERR_OK;
}
uint32_t iot_sg_sta_flash_cfg_get_cfg_len()
{
return 0;
}
uint32_t iot_sg_sta_flash_js_task_cfg_get_by_type(uint8_t task_type,
iot_sg_meter_js_task_config_hdr_t *cfg)
{
(void)task_type;
(void)cfg;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_js_task_cfg_get_by_id(uint8_t id,
iot_sg_meter_js_task_config_hdr_t *cfg)
{
(void)id;
(void)cfg;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_js_task_cfg_get_by_num(uint8_t num,
iot_sg_meter_js_task_config_hdr_t *cfg)
{
(void)num;
(void)cfg;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_js_task_cfg_save(uint8_t task_type,
iot_sg_meter_js_task_config_hdr_t *cfg)
{
(void)task_type;
(void)cfg;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_tsfm_topo_record_get(
iot_sg_sta_flash_tsfm_topo_record_t *record)
{
(void)record;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_tsfm_topo_record_save(
iot_sg_sta_flash_tsfm_topo_record_t *record)
{
(void)record;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_fj_ct_cfg_save(iot_sg_sta_flash_fj_ct_cfg_t *ct_cfg)
{
(void)ct_cfg;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_fj_ct_rec_save(iot_sg_sta_flash_fj_ct_rec_t *ct_rec)
{
(void)ct_rec;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_fj_ct_cfg_get(iot_sg_sta_flash_fj_ct_cfg_t *ct_cfg)
{
(void)ct_cfg;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_fj_latest_ct_rec_get(
iot_sg_sta_flash_fj_ct_rec_t *ct_rec) {
(void)ct_rec;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_fj_evt_rpt_cfg_save(
iot_sg_sta_flash_fj_evt_rpt_cfg_t *cfg)
{
(void)cfg;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_fj_evt_rpt_cfg_get(
iot_sg_sta_flash_fj_evt_rpt_cfg_t *cfg)
{
(void)cfg;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_fj_pwr_rpt_cfg_save(
iot_sg_sta_flash_fj_pwr_rpt_cfg_t *cfg)
{
(void)cfg;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_fj_pwr_rpt_cfg_get(
iot_sg_sta_flash_fj_pwr_rpt_cfg_t *cfg)
{
(void)cfg;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_fj_pwr_record_get(
iot_sg_sta_flash_fj_pwr_rec_t *record, uint8_t last_index)
{
(void)record;
(void)last_index;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_fj_pwr_record_save(
iot_sg_sta_flash_fj_pwr_rec_t *record, uint8_t is_overlast)
{
(void)record;
(void)is_overlast;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_fj_pwr_record_clear()
{
return ERR_OK;
}
uint32_t iot_sg_sta_flash_fj_task_comm_cfg_save(
iot_sg_sta_flash_fj_task_comm_cfg_t *cfg)
{
(void)cfg;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_fj_task_comm_cfg_get(
iot_sg_sta_flash_fj_task_comm_cfg_t *cfg)
{
(void)cfg;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_nw_task_cfg_save(
iot_sg_sta_flash_nw_task_cfg_info_t *cfg, uint8_t task_type)
{
(void)cfg;
(void)task_type;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_nw_task_cfg_get(
iot_sg_sta_flash_nw_task_cfg_info_t *cfg, uint8_t task_type, uint8_t *addr)
{
(void)cfg;
(void)task_type;
(void)addr;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_nw_edge_computing_cfg_get(
iot_sg_sta_flash_nw_edge_computing_cfg_info_t *cfg)
{
(void)cfg;
return ERR_NOSUPP;
}
uint32_t iot_sg_sta_flash_nw_edge_computing_cfg_save(
iot_sg_sta_flash_nw_edge_computing_cfg_info_t *cfg)
{
(void)cfg;
return ERR_NOSUPP;
}
#endif /* IOT_SMART_GRID_FLASH_ENABLE */
Reference in New Issue View Git Blame Copy Permalink