access.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2017 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_MESH_ACCESS_H_
#define ZEPHYR_INCLUDE_BLUETOOTH_MESH_ACCESS_H_
 
#include <zephyr/sys/util.h>
#include <zephyr/settings/settings.h>
#include <zephyr/bluetooth/assigned_numbers.h>
#include <zephyr/bluetooth/mesh/msg.h>
 
/* Internal macros used to initialize array members */
#define BT_MESH_KEY_UNUSED_ELT_(IDX, _) BT_MESH_KEY_UNUSED
#define BT_MESH_ADDR_UNASSIGNED_ELT_(IDX, _) BT_MESH_ADDR_UNASSIGNED
#define BT_MESH_UUID_UNASSIGNED_ELT_(IDX, _) NULL
#define BT_MESH_MODEL_KEYS_UNUSED(_keys)                        \
        { LISTIFY(_keys, BT_MESH_KEY_UNUSED_ELT_, (,)) }
#define BT_MESH_MODEL_GROUPS_UNASSIGNED(_grps)                  \
        { LISTIFY(_grps, BT_MESH_ADDR_UNASSIGNED_ELT_, (,)) }
#if CONFIG_BT_MESH_LABEL_COUNT > 0
#define BT_MESH_MODEL_UUIDS_UNASSIGNED()                        \
        .uuids = (const uint8_t *[]){ LISTIFY(CONFIG_BT_MESH_LABEL_COUNT, \
                                     BT_MESH_UUID_UNASSIGNED_ELT_, (,)) },
#else
#define BT_MESH_MODEL_UUIDS_UNASSIGNED()
#endif
 
#define BT_MESH_MODEL_RUNTIME_INIT(_user_data)                  \
        .rt = &(struct bt_mesh_model_rt_ctx){ .user_data = (_user_data) },

 
#ifdef __cplusplus
extern "C" {
#endif

#define BT_MESH_ADDR_UNASSIGNED    0x0000   
#define BT_MESH_ADDR_ALL_NODES     0xffff   
#define BT_MESH_ADDR_RELAYS        0xfffe   
#define BT_MESH_ADDR_FRIENDS       0xfffd   
#define BT_MESH_ADDR_PROXIES       0xfffc   
#define BT_MESH_ADDR_DFW_NODES     0xfffb   
#define BT_MESH_ADDR_IP_NODES      0xfffa   
#define BT_MESH_ADDR_IP_BR_ROUTERS 0xfff9   

#define BT_MESH_KEY_UNUSED        0xffff          
#define BT_MESH_KEY_ANY           0xffff          
#define BT_MESH_KEY_DEV           0xfffe          
#define BT_MESH_KEY_DEV_LOCAL     BT_MESH_KEY_DEV 
#define BT_MESH_KEY_DEV_REMOTE    0xfffd          
#define BT_MESH_KEY_DEV_ANY       0xfffc          

#define BT_MESH_ADDR_IS_UNICAST(addr) ((addr) && (addr) < 0x8000)
#define BT_MESH_ADDR_IS_GROUP(addr) ((addr) >= 0xc000 && (addr) < 0xff00)
#define BT_MESH_ADDR_IS_FIXED_GROUP(addr) ((addr) >= 0xff00 && (addr) < 0xffff)
#define BT_MESH_ADDR_IS_VIRTUAL(addr) ((addr) >= 0x8000 && (addr) < 0xc000)
#define BT_MESH_ADDR_IS_RFU(addr) ((addr) >= 0xff00 && (addr) <= 0xfff8)

#define BT_MESH_IS_DEV_KEY(key) (key == BT_MESH_KEY_DEV_LOCAL || \
                                 key == BT_MESH_KEY_DEV_REMOTE)

#define BT_MESH_APP_SEG_SDU_MAX   12

#define BT_MESH_APP_UNSEG_SDU_MAX 15

#if defined(CONFIG_BT_MESH_RX_SEG_MAX)
#define BT_MESH_RX_SEG_MAX CONFIG_BT_MESH_RX_SEG_MAX
#else
#define BT_MESH_RX_SEG_MAX 0
#endif

#if defined(CONFIG_BT_MESH_TX_SEG_MAX)
#define BT_MESH_TX_SEG_MAX CONFIG_BT_MESH_TX_SEG_MAX
#else
#define BT_MESH_TX_SEG_MAX 0
#endif

#define BT_MESH_TX_SDU_MAX        MAX((BT_MESH_TX_SEG_MAX *             \
                                       BT_MESH_APP_SEG_SDU_MAX),        \
                                      BT_MESH_APP_UNSEG_SDU_MAX)

#define BT_MESH_RX_SDU_MAX        MAX((BT_MESH_RX_SEG_MAX *             \
                                       BT_MESH_APP_SEG_SDU_MAX),        \
                                      BT_MESH_APP_UNSEG_SDU_MAX)

#define BT_MESH_ELEM(_loc, _mods, _vnd_mods)                            \
{                                                                       \
        .rt               = &(struct bt_mesh_elem_rt_ctx) { 0 },        \
        .loc              = (_loc),                                     \
        .model_count      = ARRAY_SIZE(_mods),                          \
        .vnd_model_count  = ARRAY_SIZE(_vnd_mods),                      \
        .models           = (_mods),                                    \
        .vnd_models       = (_vnd_mods),                                \
}

struct bt_mesh_elem {
        struct bt_mesh_elem_rt_ctx {
                uint16_t addr;
        } * const rt;

        const uint16_t loc;
        const uint8_t model_count;
        const uint8_t vnd_model_count;

        const struct bt_mesh_model * const models;
        const struct bt_mesh_model * const vnd_models;
};

struct bt_mesh_model_op {
        const uint32_t  opcode;

        const ssize_t len;

        int (*const func)(const struct bt_mesh_model *model,
                          struct bt_mesh_msg_ctx *ctx,
                          struct net_buf_simple *buf);
};
 
#define BT_MESH_MODEL_OP_1(b0) (b0)
#define BT_MESH_MODEL_OP_2(b0, b1) (((b0) << 8) | (b1))
#define BT_MESH_MODEL_OP_3(b0, cid) ((((b0) << 16) | 0xc00000) | (cid))

#define BT_MESH_LEN_EXACT(len) (-len)
#define BT_MESH_LEN_MIN(len) (len)

#define BT_MESH_MODEL_OP_END { 0, 0, NULL }
 
#if !defined(__cplusplus) || defined(__DOXYGEN__)
#define BT_MESH_MODEL_NO_OPS ((struct bt_mesh_model_op []) \
                              { BT_MESH_MODEL_OP_END })

#define BT_MESH_MODEL_NONE ((const struct bt_mesh_model []){})

#define BT_MESH_MODEL_CNT_CB(_id, _op, _pub, _user_data, _keys, _grps, _cb)     \
{                                                                               \
        .id = (_id),                                                            \
        BT_MESH_MODEL_RUNTIME_INIT(_user_data)                                  \
        .pub = _pub,                                                            \
        .keys = (uint16_t []) BT_MESH_MODEL_KEYS_UNUSED(_keys),                 \
        .keys_cnt = _keys,                                                      \
        .groups = (uint16_t []) BT_MESH_MODEL_GROUPS_UNASSIGNED(_grps),         \
        .groups_cnt = _grps,                                                    \
        BT_MESH_MODEL_UUIDS_UNASSIGNED()                                        \
        .op = _op,                                                              \
        .cb = _cb,                                                              \
}

#define BT_MESH_MODEL_CNT_VND_CB(_company, _id, _op, _pub, _user_data, _keys, _grps, _cb)       \
{                                                                                               \
        .vnd.company = (_company),                                                              \
        .vnd.id = (_id),                                                                        \
        BT_MESH_MODEL_RUNTIME_INIT(_user_data)                                                  \
        .op = _op,                                                                              \
        .pub = _pub,                                                                            \
        .keys = (uint16_t []) BT_MESH_MODEL_KEYS_UNUSED(_keys),                                 \
        .keys_cnt = _keys,                                                                      \
        .groups = (uint16_t []) BT_MESH_MODEL_GROUPS_UNASSIGNED(_grps),                         \
        .groups_cnt = _grps,                                                                    \
        BT_MESH_MODEL_UUIDS_UNASSIGNED()                                                        \
        .cb = _cb,                                                                              \
}

#define BT_MESH_MODEL_CB(_id, _op, _pub, _user_data, _cb)       \
        BT_MESH_MODEL_CNT_CB(_id, _op, _pub, _user_data,        \
                             CONFIG_BT_MESH_MODEL_KEY_COUNT,    \
                             CONFIG_BT_MESH_MODEL_GROUP_COUNT, _cb)
 

#if defined(CONFIG_BT_MESH_LARGE_COMP_DATA_SRV)
#define BT_MESH_MODEL_METADATA_CB(_id, _op, _pub, _user_data, _cb, _metadata)                    \
{                                                                            \
        .id = (_id),                                                         \
        BT_MESH_MODEL_RUNTIME_INIT(_user_data)                               \
        .pub = _pub,                                                         \
        .keys = (uint16_t []) BT_MESH_MODEL_KEYS_UNUSED(CONFIG_BT_MESH_MODEL_KEY_COUNT), \
        .keys_cnt = CONFIG_BT_MESH_MODEL_KEY_COUNT,                          \
        .groups = (uint16_t []) BT_MESH_MODEL_GROUPS_UNASSIGNED(CONFIG_BT_MESH_MODEL_GROUP_COUNT), \
        .groups_cnt = CONFIG_BT_MESH_MODEL_GROUP_COUNT,                      \
        BT_MESH_MODEL_UUIDS_UNASSIGNED()                                     \
        .op = _op,                                                           \
        .cb = _cb,                                                           \
        .metadata = _metadata,                                               \
}
#else
#define BT_MESH_MODEL_METADATA_CB(_id, _op, _pub, _user_data, _cb, _metadata)  \
        BT_MESH_MODEL_CB(_id, _op, _pub, _user_data, _cb)
#endif

#define BT_MESH_MODEL_VND_CB(_company, _id, _op, _pub, _user_data, _cb) \
        BT_MESH_MODEL_CNT_VND_CB(_company, _id, _op, _pub, _user_data,  \
                                 CONFIG_BT_MESH_MODEL_KEY_COUNT,        \
                                 CONFIG_BT_MESH_MODEL_GROUP_COUNT, _cb)

#if defined(CONFIG_BT_MESH_LARGE_COMP_DATA_SRV)
#define BT_MESH_MODEL_VND_METADATA_CB(_company, _id, _op, _pub, _user_data, _cb, _metadata)      \
{                                                                            \
        .vnd.company = (_company),                                           \
        .vnd.id = (_id),                                                     \
        BT_MESH_MODEL_RUNTIME_INIT(_user_data)                               \
        .op = _op,                                                           \
        .pub = _pub,                                                         \
        .keys = (uint16_t []) BT_MESH_MODEL_KEYS_UNUSED(CONFIG_BT_MESH_MODEL_KEY_COUNT), \
        .keys_cnt = CONFIG_BT_MESH_MODEL_KEY_COUNT,                          \
        .groups = (uint16_t []) BT_MESH_MODEL_GROUPS_UNASSIGNED(CONFIG_BT_MESH_MODEL_GROUP_COUNT), \
        .groups_cnt = CONFIG_BT_MESH_MODEL_GROUP_COUNT,                      \
        BT_MESH_MODEL_UUIDS_UNASSIGNED()                                     \
        .cb = _cb,                                                           \
        .metadata = _metadata,                                               \
}
#else
#define BT_MESH_MODEL_VND_METADATA_CB(_company, _id, _op, _pub, _user_data, _cb, _metadata)      \
        BT_MESH_MODEL_VND_CB(_company, _id, _op, _pub, _user_data, _cb)
#endif
#define BT_MESH_MODEL(_id, _op, _pub, _user_data)                              \
        BT_MESH_MODEL_CB(_id, _op, _pub, _user_data, NULL)

#define BT_MESH_MODEL_VND(_company, _id, _op, _pub, _user_data)                \
        BT_MESH_MODEL_VND_CB(_company, _id, _op, _pub, _user_data, NULL)
#endif /* !defined(__cplusplus) || defined(__DOXYGEN__) */

#define BT_MESH_TRANSMIT(count, int_ms) ((uint8_t)((count) | (((int_ms / 10) - 1) << 3)))

#define BT_MESH_TRANSMIT_COUNT(transmit) (((transmit) & (uint8_t)BIT_MASK(3)))

#define BT_MESH_TRANSMIT_INT(transmit) ((((transmit) >> 3) + 1) * 10)

#define BT_MESH_PUB_TRANSMIT(count, int_ms) BT_MESH_TRANSMIT(count,           \
                                                             (int_ms) / 5)

#define BT_MESH_PUB_TRANSMIT_COUNT(transmit) BT_MESH_TRANSMIT_COUNT(transmit)

#define BT_MESH_PUB_TRANSMIT_INT(transmit) ((((transmit) >> 3) + 1) * 50)

#define BT_MESH_PUB_MSG_TOTAL(pub) (BT_MESH_PUB_TRANSMIT_COUNT((pub)->retransmit) + 1)

#define BT_MESH_PUB_MSG_NUM(pub) (BT_MESH_PUB_TRANSMIT_COUNT((pub)->retransmit) + 1 - (pub)->count)

struct bt_mesh_model_pub {
        const struct bt_mesh_model *mod;
 
        uint16_t addr;          
        const uint8_t *uuid;    
        uint16_t key:12,        
                 cred:1,        
                 send_rel:1,    
                 fast_period:1, 
                 retr_update:1; 
 
        uint8_t  ttl;          
        uint8_t  retransmit;   
        uint8_t  period;       
        uint8_t  period_div:4, 
                 count:4;      
 
        uint8_t delayable:1;   
 
        uint32_t period_start; 

        struct net_buf_simple *msg;

        int (*update)(const struct bt_mesh_model *mod);

        struct k_work_delayable timer;
};

#define BT_MESH_MODEL_PUB_DEFINE(_name, _update, _msg_len) \
        NET_BUF_SIMPLE_DEFINE_STATIC(bt_mesh_pub_msg_##_name, _msg_len); \
        static struct bt_mesh_model_pub _name = { \
                .msg = &bt_mesh_pub_msg_##_name, \
                .update = _update, \
        }

struct bt_mesh_models_metadata_entry {
        /* Length of the metadata */
        const uint16_t len;
 
        /* ID of the metadata */
        const uint16_t id;
 
        /* Pointer to raw data */
        const void * const data;
};

#define BT_MESH_MODELS_METADATA_ENTRY(_len, _id, _data)                         \
        {                                                                      \
                .len = (_len), .id = _id, .data = _data,                       \
        }

#define BT_MESH_MODELS_METADATA_NONE NULL

#define BT_MESH_MODELS_METADATA_END { 0, 0, NULL }

struct bt_mesh_model_cb {
        int (*const settings_set)(const struct bt_mesh_model *model,
                                  const char *name, size_t len_rd,
                                  settings_read_cb read_cb, void *cb_arg);

        int (*const start)(const struct bt_mesh_model *model);

        int (*const init)(const struct bt_mesh_model *model);

        void (*const reset)(const struct bt_mesh_model *model);

        void (*const pending_store)(const struct bt_mesh_model *model);
};

struct bt_mesh_mod_id_vnd {
        uint16_t company;
        uint16_t id;
};

struct bt_mesh_model {
        union {
                const uint16_t id;
                const struct bt_mesh_mod_id_vnd vnd;
        };
 
        /* Model runtime information */
        struct bt_mesh_model_rt_ctx {
                uint8_t  elem_idx;   /* Belongs to Nth element */
                uint8_t  mod_idx;    /* Is the Nth model in the element */
                uint16_t flags;      /* Model flags for internal bookkeeping */
 
#ifdef CONFIG_BT_MESH_MODEL_EXTENSIONS
                /* Pointer to the next model in a model extension list. */
                const struct bt_mesh_model *next;
#endif
                void *user_data;
        } * const rt;

        struct bt_mesh_model_pub * const pub;

        uint16_t * const keys;
        const uint16_t keys_cnt;

        uint16_t * const groups;
        const uint16_t groups_cnt;
 
#if (CONFIG_BT_MESH_LABEL_COUNT > 0) || defined(__DOXYGEN__)
        const uint8_t ** const uuids;
#endif

        const struct bt_mesh_model_op * const op;

        const struct bt_mesh_model_cb * const cb;
 
#if defined(CONFIG_BT_MESH_LARGE_COMP_DATA_SRV) || defined(__DOXYGEN__)
        /* Pointer to the array of model metadata entries. */
        const struct bt_mesh_models_metadata_entry * const metadata;
#endif
};

struct bt_mesh_send_cb {
        void (*start)(uint16_t duration, int err, void *cb_data);
        void (*end)(int err, void *cb_data);
};
 

#define BT_MESH_TTL_DEFAULT 0xff

#define BT_MESH_TTL_MAX     0x7f

int bt_mesh_model_send(const struct bt_mesh_model *model,
                       struct bt_mesh_msg_ctx *ctx,
                       struct net_buf_simple *msg,
                       const struct bt_mesh_send_cb *cb,
                       void *cb_data);

int bt_mesh_model_publish(const struct bt_mesh_model *model);

static inline bool bt_mesh_model_pub_is_retransmission(const struct bt_mesh_model *model)
{
        return model->pub->count != BT_MESH_PUB_TRANSMIT_COUNT(model->pub->retransmit);
}

const struct bt_mesh_elem *bt_mesh_model_elem(const struct bt_mesh_model *mod);

const struct bt_mesh_model *bt_mesh_model_find(const struct bt_mesh_elem *elem,
                                               uint16_t id);

const struct bt_mesh_model *bt_mesh_model_find_vnd(const struct bt_mesh_elem *elem,
                                                   uint16_t company, uint16_t id);

static inline bool bt_mesh_model_in_primary(const struct bt_mesh_model *mod)
{
        return (mod->rt->elem_idx == 0);
}

int bt_mesh_model_data_store(const struct bt_mesh_model *mod, bool vnd,
                             const char *name, const void *data,
                             size_t data_len);

void bt_mesh_model_data_store_schedule(const struct bt_mesh_model *mod);

int bt_mesh_model_extend(const struct bt_mesh_model *extending_mod,
                         const struct bt_mesh_model *base_mod);

 
int bt_mesh_model_correspond(const struct bt_mesh_model *corresponding_mod,
                             const struct bt_mesh_model *base_mod);

bool bt_mesh_model_is_extended(const struct bt_mesh_model *model);

int bt_mesh_comp_change_prepare(void);

int bt_mesh_models_metadata_change_prepare(void);

struct bt_mesh_comp {
        uint16_t cid; 
        uint16_t pid; 
        uint16_t vid; 
 
        size_t elem_count; 
        const struct bt_mesh_elem *elem; 
};

struct bt_mesh_comp2_record {
        uint16_t id;
        struct {
                uint8_t x;
                uint8_t y;
                uint8_t z;
        } version;
        uint8_t elem_offset_cnt;
        const uint8_t *elem_offset;
        uint16_t data_len;
        const void *data;
};

struct bt_mesh_comp2 {
        size_t record_cnt;
        const struct bt_mesh_comp2_record *record;
};

int bt_mesh_comp2_register(const struct bt_mesh_comp2 *comp2);
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_MESH_ACCESS_H_ */