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>
#include <zephyr/bluetooth/mesh.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
};
 
/* doc string cdb node start */
struct bt_mesh_cdb_node {
        uint8_t  uuid[16];
        uint16_t addr;
        uint16_t net_idx;
        uint8_t  num_elem;
        struct bt_mesh_key dev_key;
        ATOMIC_DEFINE(flags, BT_MESH_CDB_NODE_FLAG_COUNT);
};
/* doc string cdb node end */
 
/* doc string cdb subnet start */
struct bt_mesh_cdb_subnet {
        uint16_t net_idx;
        uint8_t kr_phase;
        struct {
                struct bt_mesh_key net_key;
        } keys[2];
};
/* doc string cdb subnet end */
 
/* doc string cdb app key start */
struct bt_mesh_cdb_app_key {
        uint16_t net_idx;
        uint16_t app_idx;
        struct {
                struct bt_mesh_key app_key;
        } keys[2];
};
/* doc string cdb app key end */
 
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,
};
 
/* doc string cdb start */
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;
/* doc string cdb end */

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);

int bt_mesh_cdb_node_key_import(struct bt_mesh_cdb_node *node, const uint8_t in[16]);

int bt_mesh_cdb_node_key_export(const struct bt_mesh_cdb_node *node, uint8_t out[16]);
 
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);

int bt_mesh_cdb_subnet_key_import(struct bt_mesh_cdb_subnet *sub, int key_idx,
                                  const uint8_t in[16]);

int bt_mesh_cdb_subnet_key_export(const struct bt_mesh_cdb_subnet *sub, int key_idx,
                                  uint8_t out[16]);

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);

int bt_mesh_cdb_app_key_import(struct bt_mesh_cdb_app_key *key, int key_idx, const uint8_t in[16]);

int bt_mesh_cdb_app_key_export(const struct bt_mesh_cdb_app_key *key, int key_idx, uint8_t out[16]);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_MESH_CDB_H_ */