main.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2017 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef __BT_MESH_MAIN_H
#define __BT_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;
 
    /* Maximum size of Input OOB supported */
    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        (*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[BT_PUB_KEY_LEN]);
 
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);
 
/* Primary Network Key index */
#define BT_MESH_NET_PRIMARY                 0x000
 
/* Features */
#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(uint8_t own_addr_type,
         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);
 
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);
 
bool bt_mesh_is_provisioned(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);
 
void bt_mesh_lpn_set_cb(void (*cb)(uint16_t friend_addr, bool established));
 
int bt_mesh_friend_terminate(uint16_t lpn_addr);
 
void bt_mesh_rpl_pending_store(uint16_t addr);
 
#ifdef __cplusplus
}
#endif
 
#endif /* __BT_MESH_MAIN_H */