cdb.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019 Tobias Svehagen
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_MESH_CDB_H_
#define ZEPHYR_INCLUDE_BLUETOOTH_MESH_CDB_H_
 
#include <stdbool.h>
#include <stdint.h>
 
#include <zephyr/sys/atomic.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#if defined(CONFIG_BT_MESH_CDB)
#define NODE_COUNT    CONFIG_BT_MESH_CDB_NODE_COUNT
#define SUBNET_COUNT  CONFIG_BT_MESH_CDB_SUBNET_COUNT
#define APP_KEY_COUNT CONFIG_BT_MESH_CDB_APP_KEY_COUNT
#else
#define NODE_COUNT    0
#define SUBNET_COUNT  0
#define APP_KEY_COUNT 0
#endif
 
enum {
        BT_MESH_CDB_NODE_CONFIGURED,
 
        BT_MESH_CDB_NODE_FLAG_COUNT
};
 
struct bt_mesh_cdb_node {
        uint8_t  uuid[16];
        uint16_t addr;
        uint16_t net_idx;
        uint8_t  num_elem;
        uint8_t  dev_key[16];
 
        ATOMIC_DEFINE(flags, BT_MESH_CDB_NODE_FLAG_COUNT);
};
 
struct bt_mesh_cdb_subnet {
        uint16_t net_idx;
 
        uint8_t kr_phase;
 
        struct {
                uint8_t net_key[16];
        } keys[2];
};
 
struct bt_mesh_cdb_app_key {
        uint16_t net_idx;
        uint16_t app_idx;
 
        struct {
                uint8_t app_key[16];
        } keys[2];
};
 
enum {
        BT_MESH_CDB_VALID,
        BT_MESH_CDB_SUBNET_PENDING,
        BT_MESH_CDB_KEYS_PENDING,
        BT_MESH_CDB_NODES_PENDING,
        BT_MESH_CDB_IVU_IN_PROGRESS,
 
        BT_MESH_CDB_FLAG_COUNT,
};
 
struct bt_mesh_cdb {
        uint32_t iv_index;
        uint16_t lowest_avail_addr;
 
        ATOMIC_DEFINE(flags, BT_MESH_CDB_FLAG_COUNT);
 
        struct bt_mesh_cdb_node nodes[NODE_COUNT];
        struct bt_mesh_cdb_subnet subnets[SUBNET_COUNT];
        struct bt_mesh_cdb_app_key app_keys[APP_KEY_COUNT];
};
 
extern struct bt_mesh_cdb bt_mesh_cdb;
 
int bt_mesh_cdb_create(const uint8_t key[16]);
 
void bt_mesh_cdb_clear(void);
 
void bt_mesh_cdb_iv_update(uint32_t iv_index, bool iv_update);
 
struct bt_mesh_cdb_node *bt_mesh_cdb_node_alloc(const uint8_t uuid[16], uint16_t addr,
                                                uint8_t num_elem, uint16_t net_idx);
 
uint16_t bt_mesh_cdb_free_addr_get(uint8_t num_elem);
 
void bt_mesh_cdb_node_del(struct bt_mesh_cdb_node *node, bool store);
 
void bt_mesh_cdb_node_update(struct bt_mesh_cdb_node *node, uint16_t addr,
                             uint8_t num_elem);
 
struct bt_mesh_cdb_node *bt_mesh_cdb_node_get(uint16_t addr);
 
void bt_mesh_cdb_node_store(const struct bt_mesh_cdb_node *node);
 
enum {
        BT_MESH_CDB_ITER_STOP = 0,
        BT_MESH_CDB_ITER_CONTINUE,
};
 
typedef uint8_t (*bt_mesh_cdb_node_func_t)(struct bt_mesh_cdb_node *node,
                                        void *user_data);
 
void bt_mesh_cdb_node_foreach(bt_mesh_cdb_node_func_t func, void *user_data);
 
struct bt_mesh_cdb_subnet *bt_mesh_cdb_subnet_alloc(uint16_t net_idx);
 
void bt_mesh_cdb_subnet_del(struct bt_mesh_cdb_subnet *sub, bool store);
 
struct bt_mesh_cdb_subnet *bt_mesh_cdb_subnet_get(uint16_t net_idx);
 
void bt_mesh_cdb_subnet_store(const struct bt_mesh_cdb_subnet *sub);
 
uint8_t bt_mesh_cdb_subnet_flags(const struct bt_mesh_cdb_subnet *sub);
 
 
struct bt_mesh_cdb_app_key *bt_mesh_cdb_app_key_alloc(uint16_t net_idx,
                                                      uint16_t app_idx);
 
void bt_mesh_cdb_app_key_del(struct bt_mesh_cdb_app_key *key, bool store);
 
struct bt_mesh_cdb_app_key *bt_mesh_cdb_app_key_get(uint16_t app_idx);
 
void bt_mesh_cdb_app_key_store(const struct bt_mesh_cdb_app_key *key);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_MESH_CDB_H_ */