meshx_nvs.c

Go to the documentation of this file.

#include "meshx_nvs.h"
#include "interface/utils/meshx_nvs_interface.h"
 
#define MESHX_NVS_INIT_MAGIC        0x5489
 
#ifdef CONFIG_BLE_MESH_SPECIFIC_PARTITION
#define MESHX_NVS_PARTITION         CONFIG_BLE_MESH_PARTITION_NAME
#endif
 
#define MESHX_NVS_NAMESPACE_PID     "MESHX_PID"
#define MESHX_NVS_NAMESPACE_CID     "MESHX_CID"
#define MESHX_NVS_TIMER_NAME        "MESHX_COMMIT_TIMER"
#define MESHX_NVS_ELEMENT_CTX       "MESHX_API_%04x"
#define MESHX_NVS_RELOAD_ONE_SHOT   0
#define MESHX_KEY_NAME_MAX_SIZE     16
#define MESHX_KEY_VALUE_MAX_SIZE    256

typedef struct meshx_nvs_write_list
{
    uint16_t  len;                            
    char      key [MESHX_KEY_NAME_MAX_SIZE];  
    uint8_t   data[MESHX_KEY_VALUE_MAX_SIZE]; 
    struct meshx_nvs_write_list *next;        
}meshx_nvs_write_list_t;

meshx_nvs_write_list_t *meshx_nvs_write_list_head = NULL;
 
#if CONFIG_ENABLE_UNIT_TEST
#define MESHX_NVS_UNIT_TEST_KEY     "MESHX_UT"
 
static meshx_err_t meshx_nvs_unit_test_cb_handler(int cmd_id, int argc, char **argv);
#endif

static meshx_nvs_t meshx_nvs_inst;
 
#if MESHX_NVS_TIMER_PERIOD
static void meshx_nvs_os_timer_cb(const meshx_os_timer_t *p_timer)
{
    MESHX_UNUSED(p_timer);
    meshx_err_t err = MESHX_SUCCESS;
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_NVS, "%s fire", OS_TMER_GET_TIMER_NAME(p_timer));
 
    err = meshx_nvs_commit();
    if (err)
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "meshx_nvs_commit %p", (void *)err);
}
#endif /* MESHX_NVS_TIMER_PERIOD */

static meshx_err_t meshx_nvs_erase_prod_init(uint16_t cid, uint16_t pid)
{
    meshx_err_t err = MESHX_SUCCESS;
    err = meshx_nvs_erase();
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "meshx_nvs_erase %p", (void *)err);
        return err;
    }
 
    meshx_nvs_inst.pid = pid;
    meshx_nvs_inst.cid = cid;
 
    err = meshx_nvs_set(
        MESHX_NVS_NAMESPACE_PID,
        &(meshx_nvs_inst.pid),
        sizeof(meshx_nvs_inst.pid),
        MESHX_NVS_NO_AUTO_COMMIT);
 
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "meshx_nvs_set %p", (void *)err);
        return err;
    }
 
    err = meshx_nvs_set(
        MESHX_NVS_NAMESPACE_CID,
        &(meshx_nvs_inst.cid),
        sizeof(meshx_nvs_inst.cid),
        MESHX_NVS_AUTO_COMMIT);
 
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "meshx_nvs_set %p", (void *)err);
        return err;
    }
 
    return err;
}

meshx_err_t meshx_nvs_init(void)
{
    meshx_err_t err = MESHX_SUCCESS;
#if CONFIG_ENABLE_UNIT_TEST
    err = register_unit_test(MODULE_ID_COMPONENT_MESHX_NVS, &meshx_nvs_unit_test_cb_handler);
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "unit_test reg failed: (%d)", err);
        return err;
    }
#endif /* CONFIG_ENABLE_UNIT_TEST */
    return err;
}

meshx_err_t meshx_nvs_open(uint16_t cid, uint16_t pid, uint32_t commit_timeout_ms)
{
    if (meshx_nvs_inst.init == MESHX_NVS_INIT_MAGIC)
    {
        return MESHX_INVALID_STATE;
    }
 
    meshx_err_t err;
 
    err = meshx_nvs_plat_open(&(meshx_nvs_inst.meshx_nvs_handle));
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "nvs_open %p", (void *)err);
        return err;
    }
 
#if MESHX_NVS_TIMER_PERIOD
    if(commit_timeout_ms == 0)
    {
        commit_timeout_ms = MESHX_NVS_TIMER_PERIOD;
    }
    err = meshx_os_timer_create(
        MESHX_NVS_TIMER_NAME,
        commit_timeout_ms,
        MESHX_NVS_RELOAD_ONE_SHOT,
        &meshx_nvs_os_timer_cb,
        &(meshx_nvs_inst.meshx_nvs_commit_tmr));
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "os_timer_create %p", (void *)err);
        return err;
    }
#else
    MESHX_UNUSED(commit_timeout_ms);
#endif /* MESHX_NVS_TIMER_PERIOD */
 
    meshx_nvs_inst.init = MESHX_NVS_INIT_MAGIC;
 
    err = meshx_nvs_get(
        MESHX_NVS_NAMESPACE_CID,
            &(meshx_nvs_inst.cid),
        sizeof(meshx_nvs_inst.cid));
 
    err += meshx_nvs_get(
        MESHX_NVS_NAMESPACE_PID,
            &(meshx_nvs_inst.pid),
        sizeof(meshx_nvs_inst.pid));
 
    if(err != MESHX_SUCCESS)
    {
        MESHX_LOGW(MODULE_ID_COMPONENT_MESHX_NVS, "Product ID not found in NVS reinitializing MeshX NVS");
        err = meshx_nvs_erase_prod_init(cid, pid);
    }
 
    else
    {
        if (meshx_nvs_inst.cid == cid && meshx_nvs_inst.pid == pid)
        {
            MESHX_LOGI(MODULE_ID_COMPONENT_MESHX_NVS, "Product ID match: %x|%x", meshx_nvs_inst.pid, meshx_nvs_inst.cid);
        }
        else
        {
            MESHX_LOGW(MODULE_ID_COMPONENT_MESHX_NVS, "Product ID mismatch: %x|%x", meshx_nvs_inst.pid, meshx_nvs_inst.cid);
            err = meshx_nvs_erase_prod_init(cid, pid);
        }
    }
 
    return err;
}

meshx_err_t meshx_nvs_erase(void)
{
    if (meshx_nvs_inst.init != MESHX_NVS_INIT_MAGIC)
        return MESHX_INVALID_STATE;
 
    return meshx_nvs_plat_erase(meshx_nvs_inst.meshx_nvs_handle);
}

meshx_err_t meshx_nvs_commit(void)
{
    if (meshx_nvs_inst.init != MESHX_NVS_INIT_MAGIC)
        return MESHX_INVALID_STATE;
 
    meshx_err_t err = MESHX_SUCCESS;
    meshx_nvs_write_list_t *cur = meshx_nvs_write_list_head;
    meshx_nvs_write_list_t *prev;
 
    while (cur) {
        err = meshx_nvs_plat_write(meshx_nvs_inst.meshx_nvs_handle, cur->key, cur->data, cur->len);
        if (err) {
            MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "commit failed for key: %s", cur->key);
        }
        prev = cur;
        cur = cur->next;
        free(prev);
    }
 
    meshx_nvs_write_list_head = NULL;
 
    if (err == MESHX_SUCCESS) {
        // Only commit to platform once, after all writes
        err = meshx_nvs_plat_commit(meshx_nvs_inst.meshx_nvs_handle);
    }
 
    return err;
}
 

meshx_err_t meshx_nvs_close(void)
{
    meshx_err_t err = MESHX_SUCCESS;
    if (meshx_nvs_inst.init != MESHX_NVS_INIT_MAGIC)
        return MESHX_INVALID_STATE;
 
    err = meshx_nvs_plat_close(meshx_nvs_inst.meshx_nvs_handle);
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "nvs_close %p", (void *)err);
    }
 
#if MESHX_NVS_TIMER_PERIOD
    err = meshx_os_timer_delete(&(meshx_nvs_inst.meshx_nvs_commit_tmr));
#endif /* MESHX_NVS_TIMER_PERIOD */
    meshx_nvs_inst.init = 0;
    return err;
}

meshx_err_t meshx_nvs_remove(char const *key)
{
    if (meshx_nvs_inst.init != MESHX_NVS_INIT_MAGIC)
        return MESHX_INVALID_STATE;
 
    return meshx_nvs_plat_remove(meshx_nvs_inst.meshx_nvs_handle, key);
}

meshx_err_t meshx_nvs_get(char const *key, void *blob, uint16_t blob_size)
{
    if (meshx_nvs_inst.init != MESHX_NVS_INIT_MAGIC)
        return MESHX_INVALID_STATE;
    return meshx_nvs_plat_read(meshx_nvs_inst.meshx_nvs_handle, key, blob, blob_size);
}

meshx_err_t meshx_nvs_set(char const* key, void const* blob, uint16_t blob_size, bool arm_timer)
{
    if (meshx_nvs_inst.init != MESHX_NVS_INIT_MAGIC)
        return MESHX_INVALID_STATE;
 
    if (blob_size > MESHX_KEY_VALUE_MAX_SIZE)
        return MESHX_INVALID_ARG;
 
    // Check if key already exists in list → overwrite instead of duplicate
    meshx_nvs_write_list_t *cur = meshx_nvs_write_list_head;
    while (cur) {
        if (strncmp(cur->key, key, MESHX_KEY_NAME_MAX_SIZE-1) == 0)
        {
            cur->key[MESHX_KEY_NAME_MAX_SIZE - 1] = '\0';
            memcpy(cur->data, blob, blob_size);
            cur->len = blob_size;
            goto restart_timer;  // skip new node alloc
        }
        cur = cur->next;
    }
 
    // Allocate new node
    meshx_nvs_write_list_t *node = malloc(sizeof(meshx_nvs_write_list_t));
    if (!node) return MESHX_NO_MEM;
 
    strncpy(node->key, key, MESHX_KEY_NAME_MAX_SIZE);
    memcpy(node->data, blob, blob_size);
    node->len = blob_size;
    node->next = meshx_nvs_write_list_head;
    meshx_nvs_write_list_head = node;
 
restart_timer:
    if (arm_timer)
    {
#if MESHX_NVS_TIMER_PERIOD
        meshx_err_t err = meshx_os_timer_restart(meshx_nvs_inst.meshx_nvs_commit_tmr);
        if (err)
            MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "os_timer_restart err: %p", (void*)err);
#endif
    }
 
    return MESHX_SUCCESS;
}
 

meshx_err_t meshx_nvs_element_ctx_get(uint16_t element_id, void *blob, size_t blob_size)
{
    char key[MESHX_KEY_NAME_MAX_SIZE];
    snprintf(key, MESHX_KEY_NAME_MAX_SIZE, MESHX_NVS_ELEMENT_CTX, element_id);
    return meshx_nvs_get(key, blob, blob_size);
}

meshx_err_t meshx_nvs_element_ctx_set(uint16_t element_id, const void *blob, size_t blob_size)
{
    char key[MESHX_KEY_NAME_MAX_SIZE];
    snprintf(key, MESHX_KEY_NAME_MAX_SIZE, MESHX_NVS_ELEMENT_CTX, element_id);
    return meshx_nvs_set(key, blob, (uint16_t) blob_size, MESHX_NVS_AUTO_COMMIT);
}

meshx_err_t meshx_nvs_element_ctx_remove(uint16_t element_id)
{
    char key[MESHX_KEY_NAME_MAX_SIZE];
    snprintf(key, MESHX_KEY_NAME_MAX_SIZE, MESHX_NVS_ELEMENT_CTX, element_id);
    return meshx_nvs_remove(key);
}
 
#if CONFIG_ENABLE_UNIT_TEST

typedef enum meshx_nvs_cli_cmd{
    MESHX_NVS_CLI_CMD_OPEN,         /* ut 3 0 0 */
    MESHX_NVS_CLI_CMD_SET,          /* ut 3 1 1 [arm_timer?] */
    MESHX_NVS_CLI_CMD_GET,          /* ut 3 2 0 */
    MESHX_NVS_CLI_CMD_COMMIT,       /* ut 3 3 0 */
    MESHX_NVS_CLI_CMD_REMOVE,       /* ut 3 4 0 */
    MESHX_NVS_CLI_CMD_ERASE,        /* ut 3 5 0 */
    MESHX_NVS_CLI_CMD_CLOSE,        /* ut 3 6 0 */
    MESHX_NVS_CLI_MAX
}meshx_nvs_cli_cmd_t;

static meshx_err_t meshx_nvs_unit_test_cb_handler(int cmd_id, int argc, char **argv)
{
    meshx_err_t err = MESHX_SUCCESS;
    uint32_t ut_blob = 0xDEAD;
    uint32_t ut_blob_get = 0x00;
    bool arm_timer;
 
    MESHX_UNUSED(argc);
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_NVS, "argc|cmd_id: %d|%d", argc, cmd_id);
    if (cmd_id >= MESHX_NVS_CLI_MAX)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "Invalid number of arguments");
        return MESHX_INVALID_ARG;
    }
 
    switch(cmd_id)
    {
        case MESHX_NVS_CLI_CMD_OPEN:
            /* MeshX NVS Open uses defaut values */
            err = meshx_nvs_open(CONFIG_CID_ID, CONFIG_PID_ID, 0);
            break;
        case MESHX_NVS_CLI_CMD_SET:
            arm_timer = UT_GET_ARG(0, bool, argv) == 0 ? MESHX_NVS_NO_AUTO_COMMIT : MESHX_NVS_AUTO_COMMIT;
            err = meshx_nvs_set(MESHX_NVS_UNIT_TEST_KEY, &ut_blob, sizeof(ut_blob), arm_timer);
            break;
        case MESHX_NVS_CLI_CMD_GET:
            err = meshx_nvs_get(MESHX_NVS_UNIT_TEST_KEY, &ut_blob_get, sizeof(ut_blob_get));
            if(err == MESHX_SUCCESS && ut_blob != ut_blob_get)
                MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "MESHX NVS Integrety Test Failed");
            break;
        case MESHX_NVS_CLI_CMD_COMMIT:
            err = meshx_nvs_commit();
            break;
        case MESHX_NVS_CLI_CMD_REMOVE:
            err = meshx_nvs_remove(MESHX_NVS_UNIT_TEST_KEY);
            break;
        case MESHX_NVS_CLI_CMD_ERASE:
            err = meshx_nvs_erase();
            break;
        case MESHX_NVS_CLI_CMD_CLOSE:
            err = meshx_nvs_close();
            break;
        default:
            err = MESHX_INVALID_ARG;
            break;
    }
 
    return err;
}
#endif /* CONFIG_ENABLE_UNIT_TEST */