mesh_config_entry.h

/* Copyright (c) 2010 - 2018, Nordic Semiconductor ASA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form, except as embedded into a Nordic
 * Semiconductor ASA integrated circuit in a product or a software update for
 * such product, must reproduce the above copyright notice, this list of
 * conditions and the following disclaimer in the documentation and/or other
 * materials provided with the distribution.
 *
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 * contributors may be used to endorse or promote products derived from this
 * software without specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 * Nordic Semiconductor ASA integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be reverse
 * engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef MESH_CONFIG_ENTRY_H__
#define MESH_CONFIG_ENTRY_H__

#include <stdint.h>
#include <stdbool.h>

#include "nrf_mesh_assert.h"
#include "nrf_mesh_section.h"
#include "nrf_error.h"
#include "mesh_config_backend_file.h"
#include "nordic_common.h"

#define MESH_CONFIG_ENTRY_ID(FILE, RECORD) (const mesh_config_entry_id_t) {(FILE), (RECORD)}

#define MESH_CONFIG_ENTRY_MAX_SIZE 64
/*****************************************************************************
 * State owner interface
 *****************************************************************************/
#define MESH_CONFIG_FILE(NAME, FILE_ID, STRATEGY) \
 static mesh_config_backend_file_t CONCAT_2(NAME, _backend_data); \
 NRF_MESH_SECTION_ITEM_REGISTER_FLASH(mesh_config_files, const mesh_config_file_params_t NAME) = \
 {.id = FILE_ID, .strategy = STRATEGY, .p_backend_data = &CONCAT_2(NAME, _backend_data)}

#define MESH_CONFIG_ENTRY(NAME, ID, MAX_COUNT, ENTRY_SIZE, SET_CB, GET_CB, DELETE_CB, DEFAULT_VALUE) \
 NRF_MESH_STATIC_ASSERT((ENTRY_SIZE) <= MESH_CONFIG_ENTRY_MAX_SIZE); \
 NRF_MESH_STATIC_ASSERT((MAX_COUNT) > 0); \
 static mesh_config_entry_flags_t m_##NAME##_state[MAX_COUNT]; \
 NRF_MESH_SECTION_ITEM_REGISTER_FLASH(mesh_config_entries, \
 const mesh_config_entry_params_t m_##NAME##_params) = \
 {.p_id = &(ID), \
 .entry_size = ENTRY_SIZE, \
 .p_default = DEFAULT_VALUE, \
 .max_count = MAX_COUNT, \
 .callbacks = {SET_CB, GET_CB, DELETE_CB}, \
 .p_state = m_##NAME##_state}

#define MESH_CONFIG_ENTRY_IMPLEMENTATION(NAME, ID, MAX_COUNT, DATA_TYPE, ENTRY_SANITATION, DEFAULT_VALUE) \
 static DATA_TYPE m_##NAME[(MAX_COUNT)]; \
 static uint32_t NAME##_set(mesh_config_entry_id_t id, const void * p_entry_param) \
 { \
 const DATA_TYPE * p_entry = p_entry_param; \
 bool params_are_valid = (ENTRY_SANITATION); \
 if (params_are_valid) \
 { \
 memcpy(&m_##NAME[id.record - (ID).record], p_entry, sizeof(DATA_TYPE)); \
 return NRF_SUCCESS; \
 } \
 else \
 { \
 return NRF_ERROR_INVALID_DATA; \
 } \
 } \
 static void NAME##_get(mesh_config_entry_id_t id, void * p_entry) \
 { \
 memcpy(p_entry, &m_##NAME[id.record - (ID).record], sizeof(DATA_TYPE)); \
 } \
 MESH_CONFIG_ENTRY(NAME, (ID), (MAX_COUNT), sizeof(DATA_TYPE), NAME##_set, NAME##_get, NULL, DEFAULT_VALUE)

#define MESH_CONFIG_ENTRY_API_DEFINE(NAME, ID, DATA_TYPE) \
 uint32_t NAME##_set(const DATA_TYPE * p_entry) \
 { \
 return mesh_config_entry_set((ID), p_entry); \
 } \
 uint32_t NAME##_get(DATA_TYPE * p_entry) \
 { \
 return mesh_config_entry_get((ID), p_entry); \
 } \
 uint32_t NAME##_delete(void) \
 { \
 return mesh_config_entry_delete((ID)); \
 }

#define MESH_CONFIG_ENTRY_ARRAY_WRAPPER_DECLARE(NAME, ID, DATA_TYPE, INDEX_TYPE, MAX_COUNT) \
 uint32_t NAME##_set(INDEX_TYPE index, const DATA_TYPE * p_entry) \
 { \
 if (index >= (MAX_COUNT)) return NRF_ERROR_INVALID_PARAM; \
 mesh_config_entry_id_t id = ID; \
 id.record += (uint16_t) index; \
 return mesh_config_entry_set(id, p_entry); \
 } \
 uint32_t NAME##_get(INDEX_TYPE index, DATA_TYPE * p_entry) \
 { \
 if (index >= (MAX_COUNT)) return NRF_ERROR_INVALID_PARAM; \
 mesh_config_entry_id_t id = ID; \
 id.record += (uint16_t) index; \
 return mesh_config_entry_get(id, p_entry); \
 } \
 uint32_t NAME##_delete(INDEX_TYPE index) \
 { \
 if (index >= (MAX_COUNT)) return NRF_ERROR_INVALID_PARAM; \
 mesh_config_entry_id_t id = ID; \
 id.record += (uint16_t) index; \
 return mesh_config_entry_delete(id); \
 }

typedef struct
{
 uint16_t file;
 uint16_t record;
} mesh_config_entry_id_t;

typedef enum
{
 MESH_CONFIG_STRATEGY_NON_PERSISTENT, 
 MESH_CONFIG_STRATEGY_CONTINUOUS, 
 MESH_CONFIG_STRATEGY_ON_POWER_DOWN, 
} mesh_config_strategy_t;

typedef uint32_t (*mesh_config_entry_set_t)(mesh_config_entry_id_t id, const void * p_entry);

typedef void (*mesh_config_entry_get_t)(mesh_config_entry_id_t id, void * p_entry);

typedef void (*mesh_config_entry_delete_t)(mesh_config_entry_id_t id);

typedef struct
{
 uint16_t id; 
 mesh_config_strategy_t strategy; 
 mesh_config_backend_file_t * p_backend_data; 
} mesh_config_file_params_t;

typedef enum
{
 MESH_CONFIG_ENTRY_FLAG_DIRTY = (1 << 0), 
 MESH_CONFIG_ENTRY_FLAG_ACTIVE = (1 << 1), 
 MESH_CONFIG_ENTRY_FLAG_BUSY = (1 << 2), 
} mesh_config_entry_flags_t;

typedef struct
{
 const mesh_config_entry_id_t * p_id;
 uint16_t entry_size; 
 uint16_t max_count; 
 const void * p_default; 
 struct
 {
 mesh_config_entry_set_t setter;
 mesh_config_entry_get_t getter;
 mesh_config_entry_delete_t deleter;
 } callbacks;
 mesh_config_entry_flags_t * p_state; 
} mesh_config_entry_params_t;

/*****************************************************************************
* User interface
*****************************************************************************/
bool mesh_config_entry_available_id(mesh_config_entry_id_t * p_id);

uint32_t mesh_config_entry_set(mesh_config_entry_id_t id, const void * p_entry);

uint32_t mesh_config_entry_get(mesh_config_entry_id_t id, void * p_entry);

uint32_t mesh_config_entry_delete(mesh_config_entry_id_t id);

#endif /* MESH_CONFIG_ENTRY_H__ */