main.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2017 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_MESH_MAIN_H_
#define ZEPHYR_INCLUDE_BLUETOOTH_MESH_MAIN_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum {
        BT_MESH_NO_OUTPUT       = 0,
        BT_MESH_BLINK           = BIT(0),
        BT_MESH_BEEP            = BIT(1),
        BT_MESH_VIBRATE         = BIT(2),
        BT_MESH_DISPLAY_NUMBER  = BIT(3),
        BT_MESH_DISPLAY_STRING  = BIT(4),
} bt_mesh_output_action_t;
 
typedef enum {
        BT_MESH_NO_INPUT      = 0,
        BT_MESH_PUSH          = BIT(0),
        BT_MESH_TWIST         = BIT(1),
        BT_MESH_ENTER_NUMBER  = BIT(2),
        BT_MESH_ENTER_STRING  = BIT(3),
} bt_mesh_input_action_t;
 
typedef enum {
        BT_MESH_PROV_ADV   = BIT(0),
        BT_MESH_PROV_GATT  = BIT(1),
} bt_mesh_prov_bearer_t;
 
typedef enum {
        BT_MESH_PROV_OOB_OTHER     = BIT(0),
        BT_MESH_PROV_OOB_URI       = BIT(1),
        BT_MESH_PROV_OOB_2D_CODE   = BIT(2),
        BT_MESH_PROV_OOB_BAR_CODE  = BIT(3),
        BT_MESH_PROV_OOB_NFC       = BIT(4),
        BT_MESH_PROV_OOB_NUMBER    = BIT(5),
        BT_MESH_PROV_OOB_STRING    = BIT(6),
        /* 7 - 10 are reserved */
        BT_MESH_PROV_OOB_ON_BOX    = BIT(11),
        BT_MESH_PROV_OOB_IN_BOX    = BIT(12),
        BT_MESH_PROV_OOB_ON_PAPER  = BIT(13),
        BT_MESH_PROV_OOB_IN_MANUAL = BIT(14),
        BT_MESH_PROV_OOB_ON_DEV    = BIT(15),
} bt_mesh_prov_oob_info_t;
 
struct bt_mesh_dev_capabilities {
        uint8_t elem_count;
 
        uint16_t algorithms;
 
        uint8_t pub_key_type;
 
        uint8_t static_oob;
 
        bt_mesh_output_action_t output_actions;
 
        bt_mesh_input_action_t input_actions;
 
        uint8_t output_size;
 
        uint8_t input_size;
};
 
struct bt_mesh_prov {
        const uint8_t *uuid;
 
        const char *uri;
 
        bt_mesh_prov_oob_info_t oob_info;
 
        const uint8_t *public_key_be;
        const uint8_t *private_key_be;
 
        const uint8_t *static_val;
        uint8_t        static_val_len;
 
        uint8_t        output_size;
        uint16_t       output_actions;
 
        uint8_t        input_size;
        uint16_t       input_actions;
 
        void         (*capabilities)(const struct bt_mesh_dev_capabilities *cap);
 
        int         (*output_number)(bt_mesh_output_action_t act, uint32_t num);
 
        int         (*output_string)(const char *str);
 
        int         (*input)(bt_mesh_input_action_t act, uint8_t size);
 
        void        (*input_complete)(void);
 
        void        (*unprovisioned_beacon)(uint8_t uuid[16],
                                            bt_mesh_prov_oob_info_t oob_info,
                                            uint32_t *uri_hash);
 
        void        (*unprovisioned_beacon_gatt)(uint8_t uuid[16],
                                                 bt_mesh_prov_oob_info_t oob_info);
 
        void        (*link_open)(bt_mesh_prov_bearer_t bearer);
 
        void        (*link_close)(bt_mesh_prov_bearer_t bearer);
 
        void        (*complete)(uint16_t net_idx, uint16_t addr);
 
        void        (*node_added)(uint16_t net_idx, uint8_t uuid[16], uint16_t addr,
                                  uint8_t num_elem);
 
        void        (*reset)(void);
};
 
int bt_mesh_input_string(const char *str);
 
int bt_mesh_input_number(uint32_t num);
 
int bt_mesh_prov_remote_pub_key_set(const uint8_t public_key[64]);
 
int bt_mesh_auth_method_set_input(bt_mesh_input_action_t action, uint8_t size);
 
int bt_mesh_auth_method_set_output(bt_mesh_output_action_t action, uint8_t size);
 
int bt_mesh_auth_method_set_static(const uint8_t *static_val, uint8_t size);
 
int bt_mesh_auth_method_set_none(void);
 
int bt_mesh_prov_enable(bt_mesh_prov_bearer_t bearers);
 
int bt_mesh_prov_disable(bt_mesh_prov_bearer_t bearers);
 
int bt_mesh_provision(const uint8_t net_key[16], uint16_t net_idx,
                      uint8_t flags, uint32_t iv_index, uint16_t addr,
                      const uint8_t dev_key[16]);
 
int bt_mesh_provision_adv(const uint8_t uuid[16], uint16_t net_idx, uint16_t addr,
                          uint8_t attention_duration);
 
int bt_mesh_provision_gatt(const uint8_t uuid[16], uint16_t net_idx, uint16_t addr,
                           uint8_t attention_duration);
 
bool bt_mesh_is_provisioned(void);
 
/* Primary Network Key index */
#define BT_MESH_NET_PRIMARY                 0x000
 
#define BT_MESH_FEAT_RELAY                  BIT(0)
#define BT_MESH_FEAT_PROXY                  BIT(1)
#define BT_MESH_FEAT_FRIEND                 BIT(2)
#define BT_MESH_FEAT_LOW_POWER              BIT(3)
#define BT_MESH_FEAT_SUPPORTED              (BT_MESH_FEAT_RELAY |   \
                                             BT_MESH_FEAT_PROXY |   \
                                             BT_MESH_FEAT_FRIEND |  \
                                             BT_MESH_FEAT_LOW_POWER)
 
int bt_mesh_init(const struct bt_mesh_prov *prov,
                 const struct bt_mesh_comp *comp);
 
void bt_mesh_reset(void);
 
int bt_mesh_suspend(void);
 
int bt_mesh_resume(void);
 
void bt_mesh_iv_update_test(bool enable);
 
bool bt_mesh_iv_update(void);
 
int bt_mesh_lpn_set(bool enable);
 
int bt_mesh_lpn_poll(void);
 
struct bt_mesh_lpn_cb {
        void (*established)(uint16_t net_idx, uint16_t friend_addr,
                            uint8_t queue_size, uint8_t recv_window);
 
        void (*terminated)(uint16_t net_idx, uint16_t friend_addr);
 
        void (*polled)(uint16_t net_idx, uint16_t friend_addr, bool retry);
};
 
#define BT_MESH_LPN_CB_DEFINE(_name)                                  \
        static const STRUCT_SECTION_ITERABLE(bt_mesh_lpn_cb,          \
                                             _CONCAT(bt_mesh_lpn_cb_, \
                                                     _name))
 
struct bt_mesh_friend_cb {
        void (*established)(uint16_t net_idx, uint16_t lpn_addr,
                            uint8_t recv_delay, uint32_t polltimeout);
 
        void (*terminated)(uint16_t net_idx, uint16_t lpn_addr);
 
        void (*polled)(uint16_t net_idx, uint16_t lpn_addr);
};
 
#define BT_MESH_FRIEND_CB_DEFINE(_name)                                  \
        static const STRUCT_SECTION_ITERABLE(bt_mesh_friend_cb,          \
                                             _CONCAT(bt_mesh_friend_cb_, \
                                                     _name))
 
int bt_mesh_friend_terminate(uint16_t lpn_addr);
 
void bt_mesh_rpl_pending_store(uint16_t addr);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_MESH_MAIN_H_ */