ble_gap.h

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
 
#ifndef H_BLE_GAP_
#define H_BLE_GAP_
 
#include <inttypes.h>
#include "ble_hs.h"
#include "ble_hs_adv.h"
#include "nimble/porting/nimble/include/syscfg/syscfg.h"
#include "ble_esp_gap.h"
 
#if MYNEWT_VAL(ENC_ADV_DATA)
#include "../../src/ble_hs_hci_priv.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct hci_le_conn_complete;
struct hci_conn_update;
 
#define BLE_GAP_ADV_ITVL_MS(t)              ((t) * 1000 / BLE_HCI_ADV_ITVL)
#define BLE_GAP_SCAN_ITVL_MS(t)             ((t) * 1000 / BLE_HCI_SCAN_ITVL)
#define BLE_GAP_SCAN_WIN_MS(t)              ((t) * 1000 / BLE_HCI_SCAN_ITVL)
#define BLE_GAP_CONN_ITVL_MS(t)             ((t) * 1000 / BLE_HCI_CONN_ITVL)
#define BLE_GAP_SUPERVISION_TIMEOUT_MS(t)   ((t) / 10)
#define BLE_GAP_PERIODIC_ITVL_MS(t)         ((t) * 1000 / BLE_HCI_PERIODIC_ADV_ITVL)
 
#if MYNEWT_VAL(BLE_HIGH_DUTY_ADV_ITVL)
#define BLE_GAP_ADV_FAST_INTERVAL1_MIN      BLE_GAP_ADV_ITVL_MS(5)
#else
#define BLE_GAP_ADV_FAST_INTERVAL1_MIN      BLE_GAP_ADV_ITVL_MS(30)
#endif
 
#define BLE_GAP_ADV_FAST_INTERVAL1_MAX      BLE_GAP_ADV_ITVL_MS(60)
 
#if MYNEWT_VAL(BLE_HIGH_DUTY_ADV_ITVL)
#define BLE_GAP_ADV_FAST_INTERVAL2_MIN      BLE_GAP_ADV_ITVL_MS(5)
#else
#define BLE_GAP_ADV_FAST_INTERVAL2_MIN      BLE_GAP_ADV_ITVL_MS(100)
#endif
 
#define BLE_GAP_ADV_FAST_INTERVAL2_MAX      BLE_GAP_ADV_ITVL_MS(150)
 
#define BLE_GAP_SCAN_FAST_INTERVAL_MIN      BLE_GAP_SCAN_ITVL_MS(30)
 
#define BLE_GAP_SCAN_FAST_INTERVAL_MAX      BLE_GAP_SCAN_ITVL_MS(60)
 
#define BLE_GAP_LIM_DISC_SCAN_INT           BLE_GAP_SCAN_ITVL_MS(11.25)
 
#define BLE_GAP_LIM_DISC_SCAN_WINDOW        BLE_GAP_SCAN_WIN_MS(11.25)
 
#define BLE_GAP_SCAN_FAST_WINDOW            BLE_GAP_SCAN_WIN_MS(30)
 
/* 30.72 seconds; active scanning. */
#define BLE_GAP_SCAN_FAST_PERIOD            BLE_GAP_SCAN_ITVL_MS(30.72)
 
#define BLE_GAP_SCAN_SLOW_INTERVAL1         BLE_GAP_SCAN_ITVL_MS(1280)
 
#define BLE_GAP_SCAN_SLOW_WINDOW1           BLE_GAP_SCAN_WIN_MS(11.25)
 
#define BLE_GAP_DISC_DUR_DFLT               (10.24 * 1000)
 
#define BLE_GAP_CONN_DUR_DFLT               (30 * 1000)
 
#define BLE_GAP_CONN_PAUSE_CENTRAL          (1 * 1000)
 
#define BLE_GAP_CONN_PAUSE_PERIPHERAL       (5 * 1000)
 
/* 30 ms. */
#define BLE_GAP_INITIAL_CONN_ITVL_MIN       BLE_GAP_CONN_ITVL_MS(30)
 
/* 50 ms. */
#define BLE_GAP_INITIAL_CONN_ITVL_MAX       BLE_GAP_CONN_ITVL_MS(50)
 
#define BLE_GAP_ADV_DFLT_CHANNEL_MAP        0x07
 
#define BLE_GAP_INITIAL_CONN_LATENCY        0
#define BLE_GAP_INITIAL_SUPERVISION_TIMEOUT 0x0100
#define BLE_GAP_INITIAL_CONN_MIN_CE_LEN     0x0000
#define BLE_GAP_INITIAL_CONN_MAX_CE_LEN     0x0000
 
#define BLE_GAP_ROLE_MASTER                 0
#define BLE_GAP_ROLE_SLAVE                  1
 
#define BLE_GAP_EVENT_CONNECT               0
#define BLE_GAP_EVENT_DISCONNECT            1
/* Reserved                                 2 */
#define BLE_GAP_EVENT_CONN_UPDATE           3
#define BLE_GAP_EVENT_CONN_UPDATE_REQ       4
#define BLE_GAP_EVENT_L2CAP_UPDATE_REQ      5
#define BLE_GAP_EVENT_TERM_FAILURE          6
#define BLE_GAP_EVENT_DISC                  7
#define BLE_GAP_EVENT_DISC_COMPLETE         8
#define BLE_GAP_EVENT_ADV_COMPLETE          9
#define BLE_GAP_EVENT_ENC_CHANGE            10
#define BLE_GAP_EVENT_PASSKEY_ACTION        11
#define BLE_GAP_EVENT_NOTIFY_RX             12
#define BLE_GAP_EVENT_NOTIFY_TX             13
#define BLE_GAP_EVENT_SUBSCRIBE             14
#define BLE_GAP_EVENT_MTU                   15
#define BLE_GAP_EVENT_IDENTITY_RESOLVED     16
#define BLE_GAP_EVENT_REPEAT_PAIRING        17
#define BLE_GAP_EVENT_PHY_UPDATE_COMPLETE   18
#define BLE_GAP_EVENT_EXT_DISC              19
#define BLE_GAP_EVENT_PERIODIC_SYNC         20
#define BLE_GAP_EVENT_PERIODIC_REPORT       21
#define BLE_GAP_EVENT_PERIODIC_SYNC_LOST    22
#define BLE_GAP_EVENT_SCAN_REQ_RCVD         23
#define BLE_GAP_EVENT_PERIODIC_TRANSFER     24
#define BLE_GAP_EVENT_PATHLOSS_THRESHOLD    25
#define BLE_GAP_EVENT_TRANSMIT_POWER        26
#define BLE_GAP_EVENT_SUBRATE_CHANGE        27
#define BLE_GAP_EVENT_VS_HCI                28
#define BLE_GAP_EVENT_REATTEMPT_COUNT       29
#define BLE_GAP_EVENT_AUTHORIZE             30
#define BLE_GAP_EVENT_TEST_UPDATE           31
#define BLE_GAP_EVENT_DATA_LEN_CHG          32
 
/* DTM events */
#define BLE_GAP_DTM_TX_START_EVT            0
#define BLE_GAP_DTM_RX_START_EVT            1
#define BLE_GAP_DTM_END_EVT                 2
 
/*** Reason codes for the subscribe GAP event. */
 
#define BLE_GAP_SUBSCRIBE_REASON_WRITE      1
 
#define BLE_GAP_SUBSCRIBE_REASON_TERM       2
 
#define BLE_GAP_SUBSCRIBE_REASON_RESTORE    3
 
#define BLE_GAP_REPEAT_PAIRING_RETRY        1
#define BLE_GAP_REPEAT_PAIRING_IGNORE       2
 
#define BLE_STATIC_RAND_ADDR_MASK           0xC0
 
#define BLE_NON_RPA_MASK                    0x3F
 
/* Response values for gatt read/write authorization event */
#define BLE_GAP_AUTHORIZE_ACCEPT            1
#define BLE_GAP_AUTHORIZE_REJECT            2
 
struct ble_gap_sec_state {
    unsigned encrypted:1;
 
    unsigned authenticated:1;
 
    unsigned bonded:1;
 
    unsigned key_size:5;
 
    unsigned authorize:1;
};
 
struct ble_gap_adv_params {
    uint8_t conn_mode;
    uint8_t disc_mode;
 
    uint16_t itvl_min;
    uint16_t itvl_max;
    uint8_t channel_map;
 
    uint8_t filter_policy;
 
    uint8_t high_duty_cycle:1;
};
 
struct ble_gap_conn_desc {
    struct ble_gap_sec_state sec_state;
 
    ble_addr_t our_id_addr;
 
    ble_addr_t peer_id_addr;
 
    ble_addr_t our_ota_addr;
 
    ble_addr_t peer_ota_addr;
 
    uint16_t conn_handle;
 
    uint16_t conn_itvl;
 
    uint16_t conn_latency;
 
    uint16_t supervision_timeout;
 
    uint8_t role;
 
    uint8_t master_clock_accuracy;
};
 
struct ble_gap_conn_params {
    uint16_t scan_itvl;
 
    uint16_t scan_window;
 
    uint16_t itvl_min;
 
    uint16_t itvl_max;
 
    uint16_t latency;
 
    uint16_t supervision_timeout;
 
    uint16_t min_ce_len;
 
    uint16_t max_ce_len;
};
 
struct ble_gap_ext_disc_params {
    uint16_t itvl;
 
    uint16_t window;
 
    uint8_t passive:1;
};
 
struct ble_gap_disc_params {
    uint16_t itvl;
 
    uint16_t window;
 
    uint8_t filter_policy;
 
    uint8_t limited:1;
 
    uint8_t passive:1;
 
    uint8_t filter_duplicates:1;
};
 
struct ble_gap_upd_params {
    uint16_t itvl_min;
 
    uint16_t itvl_max;
 
    uint16_t latency;
 
    uint16_t supervision_timeout;
 
    uint16_t min_ce_len;
 
    uint16_t max_ce_len;
};
 
struct ble_gap_passkey_params {
    uint8_t action;
 
    uint32_t numcmp;
};
 
#if MYNEWT_VAL(BLE_EXT_ADV)
 
#define BLE_GAP_EXT_ADV_DATA_STATUS_COMPLETE   0x00
#define BLE_GAP_EXT_ADV_DATA_STATUS_INCOMPLETE 0x01
#define BLE_GAP_EXT_ADV_DATA_STATUS_TRUNCATED  0x02
 
struct ble_gap_ext_disc_desc {
    uint8_t props;
 
    uint8_t data_status;
 
    uint8_t legacy_event_type;
 
    ble_addr_t addr;
 
    int8_t rssi;
 
    int8_t tx_power;
 
    uint8_t sid;
 
    uint8_t prim_phy;
 
    uint8_t sec_phy;
 
    uint16_t periodic_adv_itvl;
 
    uint8_t length_data;
 
    const uint8_t *data;
 
    ble_addr_t direct_addr;
};
#endif
 
struct ble_gap_disc_desc {
    uint8_t event_type;
 
    uint8_t length_data;
 
    ble_addr_t addr;
 
    int8_t rssi;
 
    const uint8_t *data;
 
    ble_addr_t direct_addr;
};
 
struct ble_gap_repeat_pairing {
    uint16_t conn_handle;
 
    uint8_t cur_key_size;
    uint8_t cur_authenticated:1;
    uint8_t cur_sc:1;
 
    uint8_t new_key_size;
    uint8_t new_authenticated:1;
    uint8_t new_sc:1;
    uint8_t new_bonding:1;
};
 
struct ble_gap_event {
    uint8_t type;
 
    union {
        struct {
            int status;
 
            uint16_t conn_handle;
        } connect;
 
        struct {
            int reason;
 
            struct ble_gap_conn_desc conn;
        } disconnect;
 
        struct ble_gap_disc_desc disc;
 
#if MYNEWT_VAL(BLE_EXT_ADV)
        struct ble_gap_ext_disc_desc ext_disc;
#endif
 
        struct {
            int reason;
        } disc_complete;
 
        struct {
            int reason;
 
#if MYNEWT_VAL(BLE_EXT_ADV)
            uint8_t instance;
            uint16_t conn_handle;
            uint8_t num_ext_adv_events;
#endif
        } adv_complete;
 
        struct {
            int status;
 
            uint16_t conn_handle;
        } conn_update;
 
        struct {
            const struct ble_gap_upd_params *peer_params;
 
            struct ble_gap_upd_params *self_params;
 
            uint16_t conn_handle;
        } conn_update_req;
 
        struct {
            int status;
 
            uint16_t conn_handle;
        } term_failure;
 
        struct {
            int status;
 
            uint16_t conn_handle;
        } enc_change;
 
        struct {
            struct ble_gap_passkey_params params;
 
            uint16_t conn_handle;
        } passkey;
 
        struct {
            struct os_mbuf *om;
 
            uint16_t attr_handle;
 
            uint16_t conn_handle;
 
            uint8_t indication:1;
        } notify_rx;
 
        struct {
            int status;
 
            uint16_t conn_handle;
 
            uint16_t attr_handle;
 
            uint8_t indication:1;
        } notify_tx;
 
        struct {
            uint16_t conn_handle;
 
            uint16_t attr_handle;
 
            uint8_t reason;
 
            uint8_t prev_notify:1;
 
            uint8_t cur_notify:1;
 
            uint8_t prev_indicate:1;
 
            uint8_t cur_indicate:1;
        } subscribe;
 
        struct {
            uint16_t conn_handle;
 
            uint16_t channel_id;
 
            /* The channel's new MTU. */
            uint16_t value;
        } mtu;
 
        struct {
            uint16_t conn_handle;
        } identity_resolved;
 
        struct ble_gap_repeat_pairing repeat_pairing;
 
        struct {
            int status;
            uint16_t conn_handle;
 
            uint8_t tx_phy;
            uint8_t rx_phy;
        } phy_updated;
#if MYNEWT_VAL(BLE_PERIODIC_ADV)
        struct {
            uint8_t status;
            uint16_t sync_handle;
 
            uint8_t sid;
 
            ble_addr_t adv_addr;
 
            uint8_t adv_phy;
 
            uint16_t per_adv_ival;
 
            uint8_t adv_clk_accuracy;
        } periodic_sync;
 
        struct {
            uint16_t sync_handle;
 
            int8_t tx_power;
 
            int8_t rssi;
 
            uint8_t data_status;
 
            uint8_t data_length;
 
            const uint8_t *data;
        } periodic_report;
 
        struct {
            uint16_t sync_handle;
 
            int reason;
        } periodic_sync_lost;
#endif
 
#if MYNEWT_VAL(BLE_EXT_ADV)
        struct {
            uint8_t instance;
            ble_addr_t scan_addr;
        } scan_req_rcvd;
#endif
#if MYNEWT_VAL(BLE_PERIODIC_ADV_SYNC_TRANSFER)
        struct {
            uint8_t status;
 
            uint16_t sync_handle;
 
            uint16_t conn_handle;
 
            uint16_t service_data;
 
            uint8_t sid;
 
            ble_addr_t adv_addr;
 
            uint8_t adv_phy;
 
            uint16_t per_adv_itvl;
 
            uint8_t adv_clk_accuracy;
        } periodic_transfer;
#endif
 
#if MYNEWT_VAL(BLE_POWER_CONTROL)
    struct {
        uint16_t conn_handle;
 
        uint8_t current_path_loss;
 
        uint8_t zone_entered;
    } pathloss_threshold;
 
    struct {
        uint8_t status;
 
        uint16_t conn_handle;
 
        uint8_t reason;
 
        uint8_t phy;
 
        int8_t transmit_power_level;
 
        uint8_t transmit_power_level_flag;
 
        int8_t delta;
    } transmit_power;
#endif
 
#if MYNEWT_VAL(BLE_CONN_SUBRATING)
        struct {
            uint8_t status;
 
            uint16_t conn_handle;
 
            uint16_t subrate_factor;
 
            uint16_t periph_latency;
 
            uint16_t cont_num;
 
            uint16_t supervision_tmo;
        } subrate_change;
#endif
 
#if MYNEWT_VAL(BLE_HCI_VS)
        struct {
            const void *ev;
            uint8_t length;
        } vs_hci;
#endif
 
        struct {
            /* Connection Handle */
            uint16_t conn_handle;
 
            /* Attribute handle of the attribute being accessed. */
            uint16_t attr_handle;
 
            /* Weather the operation is a read or write operation. */
            int is_read;
 
            /* User's response */
            int out_response;
        } authorize;
 
#if MYNEWT_VAL(BLE_ENABLE_CONN_REATTEMPT)
        struct {
            /* Connection handle */
        uint16_t conn_handle;
 
        /* Reattempt connection attempt count */
        uint8_t count;
        } reattempt_cnt;
#endif
    struct {
            /* Indicate DTM operation status */
        uint8_t status;
 
        /* DTM state change event. Can be following constants:
         *    o BLE_GAP_DTM_TX_START_EVT
         *    o BLE_GAP_DTM_RX_START_EVT
         *    o BLE_GAP_DTM_END_EVT
         */
            uint8_t update_evt;
 
        /* Number of packets received.
         *
         * Valid only for BLE_GAP_DTM_END_EVT
         * shall be 0 for a transmitter.
         */
            uint16_t num_pkt;
    } dtm_state;
 
    struct {
            /* Connection handle */
        uint16_t conn_handle;
 
        /* Max Tx Payload octotes */
        uint16_t max_tx_octets;
 
        /* Max Tx Time */
        uint16_t max_tx_time;
 
        /* Max Rx payload octet */
        uint16_t max_rx_octets;
 
        /* Max Rx Time */
        uint16_t max_rx_time;
    } data_len_chg;
    };
};
 
#if MYNEWT_VAL(OPTIMIZE_MULTI_CONN)
struct ble_gap_multi_conn_params {
    uint8_t own_addr_type;
 
#if MYNEWT_VAL(BLE_EXT_ADV)
    uint8_t phy_mask;
#endif // MYNEWT_VAL(BLE_EXT_ADV)
 
    const ble_addr_t *peer_addr;
 
    int32_t duration_ms;
 
    const struct ble_gap_conn_params *phy_1m_conn_params;
 
#if MYNEWT_VAL(BLE_EXT_ADV)
    const struct ble_gap_conn_params *phy_2m_conn_params;
 
    const struct ble_gap_conn_params *phy_coded_conn_params;
#endif // MYNEWT_VAL(BLE_EXT_ADV)
 
    uint32_t scheduling_len_us;
};
#endif // MYNEWT_VAL(OPTIMIZE_MULTI_CONN)
 
typedef int ble_gap_event_fn(struct ble_gap_event *event, void *arg);
 
#define BLE_GAP_CONN_MODE_NON               0
#define BLE_GAP_CONN_MODE_DIR               1
#define BLE_GAP_CONN_MODE_UND               2
 
#define BLE_GAP_DISC_MODE_NON               0
#define BLE_GAP_DISC_MODE_LTD               1
#define BLE_GAP_DISC_MODE_GEN               2
 
int ble_gap_conn_find(uint16_t handle, struct ble_gap_conn_desc *out_desc);
 
int ble_gap_conn_find_by_addr(const ble_addr_t *addr,
                              struct ble_gap_conn_desc *out_desc);
 
int ble_gap_set_event_cb(uint16_t conn_handle,
                         ble_gap_event_fn *cb, void *cb_arg);
 
int ble_gap_adv_start(uint8_t own_addr_type, const ble_addr_t *direct_addr,
                      int32_t duration_ms,
                      const struct ble_gap_adv_params *adv_params,
                      ble_gap_event_fn *cb, void *cb_arg);
 
int ble_gap_adv_stop(void);
 
int ble_gap_adv_active(void);
 
int ble_gap_adv_set_data(const uint8_t *data, int data_len);
 
int ble_gap_adv_rsp_set_data(const uint8_t *data, int data_len);
 
int ble_gap_adv_set_fields(const struct ble_hs_adv_fields *rsp_fields);
 
int ble_gap_adv_rsp_set_fields(const struct ble_hs_adv_fields *rsp_fields);
 
#if MYNEWT_VAL(ENC_ADV_DATA)
#define BLE_GAP_DATA_SERIALIZED_SIZE(data_len) ((data_len) + 2)
#define BLE_GAP_ENC_ADV_DATA    0x31
struct enc_adv_data {
    uint8_t len;
    uint8_t type;
    uint8_t *data;
};
 
#define ENC_ADV_DATA(_type, _data, _data_len) \
    { \
        .type = (_type), \
        .len = (_data_len), \
        .data = (uint8_t *)(_data), \
    }
#endif
 
#if MYNEWT_VAL(BLE_EXT_ADV)
struct ble_gap_ext_adv_params {
    unsigned int connectable:1;
 
    unsigned int scannable:1;
 
    unsigned int directed:1;
 
    unsigned int high_duty_directed:1;
 
    unsigned int legacy_pdu:1;
 
    unsigned int anonymous:1;
 
    unsigned int include_tx_power:1;
 
    unsigned int scan_req_notif:1;
 
    uint32_t itvl_min;
 
    uint32_t itvl_max;
 
    uint8_t channel_map;
 
    uint8_t own_addr_type;
 
    ble_addr_t peer;
 
    uint8_t filter_policy;
 
    uint8_t primary_phy;
 
    uint8_t secondary_phy;
 
    int8_t tx_power;
 
    uint8_t sid;
};
 
int ble_gap_ext_adv_configure(uint8_t instance,
                              const struct ble_gap_ext_adv_params *params,
                              int8_t *selected_tx_power,
                              ble_gap_event_fn *cb, void *cb_arg);
 
int ble_gap_ext_adv_set_addr(uint8_t instance, const ble_addr_t *addr);
 
int ble_gap_ext_adv_start(uint8_t instance, int duration, int max_events);
 
int ble_gap_ext_adv_stop(uint8_t instance);
 
int ble_gap_ext_adv_set_data(uint8_t instance, struct os_mbuf *data);
 
int ble_gap_ext_adv_rsp_set_data(uint8_t instance, struct os_mbuf *data);
 
int ble_gap_ext_adv_remove(uint8_t instance);
 
int ble_gap_ext_adv_clear(void);
 
int ble_gap_ext_adv_active(uint8_t instance);
#endif
 
/* Periodic Advertising */
#if MYNEWT_VAL(BLE_PERIODIC_ADV)
 
struct ble_gap_periodic_adv_params {
    unsigned int include_tx_power:1;
 
    uint16_t itvl_min;
 
    uint16_t itvl_max;
};
 
#if MYNEWT_VAL(BLE_PERIODIC_ADV_ENH)
struct ble_gap_periodic_adv_start_params {
    unsigned int include_adi:1;
};
 
struct ble_gap_periodic_adv_sync_reporting_params {
    unsigned int filter_duplicates:1;
};
 
struct ble_gap_periodic_adv_set_data_params {
    unsigned int update_did:1;
};
#endif
 
struct ble_gap_periodic_sync_params {
    uint16_t skip;
 
    uint16_t sync_timeout;
 
    unsigned int reports_disabled:1;
 
#if MYNEWT_VAL(BLE_PERIODIC_ADV_ENH)
    unsigned int filter_duplicates:1;
#endif
};
 
int ble_gap_periodic_adv_configure(uint8_t instance,
                                   const struct ble_gap_periodic_adv_params *params);
 
#if MYNEWT_VAL(BLE_PERIODIC_ADV_ENH)
int
ble_gap_periodic_adv_start(uint8_t instance,
                           const struct ble_gap_periodic_adv_start_params *params);
 
#else
int ble_gap_periodic_adv_start(uint8_t instance);
#endif
 
int ble_gap_periodic_adv_stop(uint8_t instance);
 
#if MYNEWT_VAL(BLE_PERIODIC_ADV_ENH)
int ble_gap_periodic_adv_set_data(uint8_t instance,
                                  struct os_mbuf *data,
                                  struct ble_gap_periodic_adv_set_data_params *params);
#else
int ble_gap_periodic_adv_set_data(uint8_t instance, struct os_mbuf *data);
#endif
 
int ble_gap_periodic_adv_sync_create(const ble_addr_t *addr, uint8_t adv_sid,
                                     const struct ble_gap_periodic_sync_params *params,
                                     ble_gap_event_fn *cb, void *cb_arg);
 
int ble_gap_periodic_adv_sync_create_cancel(void);
 
int ble_gap_periodic_adv_sync_terminate(uint16_t sync_handle);
 
#if MYNEWT_VAL(BLE_PERIODIC_ADV_SYNC_TRANSFER)
#if MYNEWT_VAL(BLE_PERIODIC_ADV_ENH)
int ble_gap_periodic_adv_sync_reporting(uint16_t sync_handle,
                                        bool enable,
                                        const struct ble_gap_periodic_adv_sync_reporting_params *params);
#else
int ble_gap_periodic_adv_sync_reporting(uint16_t sync_handle, bool enable);
#endif
int ble_gap_periodic_adv_sync_transfer(uint16_t sync_handle,
                                       uint16_t conn_handle,
                                       uint16_t service_data);
 
int ble_gap_periodic_adv_sync_set_info(uint8_t instance,
                                       uint16_t conn_handle,
                                       uint16_t service_data);
 
int periodic_adv_set_default_sync_params(const struct ble_gap_periodic_sync_params *params);
 
int ble_gap_periodic_adv_sync_receive(uint16_t conn_handle,
                                      const struct ble_gap_periodic_sync_params *params,
                                      ble_gap_event_fn *cb, void *cb_arg);
#endif
 
int ble_gap_add_dev_to_periodic_adv_list(const ble_addr_t *peer_addr,
                                         uint8_t adv_sid);
 
int ble_gap_rem_dev_from_periodic_adv_list(const ble_addr_t *peer_addr,
                                           uint8_t adv_sid);
 
int ble_gap_clear_periodic_adv_list(void);
 
int ble_gap_read_periodic_adv_list_size(uint8_t *per_adv_list_size);
#endif
 
 
int ble_gap_disc(uint8_t own_addr_type, int32_t duration_ms,
                 const struct ble_gap_disc_params *disc_params,
                 ble_gap_event_fn *cb, void *cb_arg);
 
int ble_gap_ext_disc(uint8_t own_addr_type, uint16_t duration, uint16_t period,
                     uint8_t filter_duplicates, uint8_t filter_policy,
                     uint8_t limited,
                     const struct ble_gap_ext_disc_params *uncoded_params,
                     const struct ble_gap_ext_disc_params *coded_params,
                     ble_gap_event_fn *cb, void *cb_arg);
 
int ble_gap_disc_cancel(void);
 
int ble_gap_disc_active(void);
 
int ble_gap_connect(uint8_t own_addr_type, const ble_addr_t *peer_addr,
                    int32_t duration_ms,
                    const struct ble_gap_conn_params *params,
                    ble_gap_event_fn *cb, void *cb_arg);
 
int ble_gap_ext_connect(uint8_t own_addr_type, const ble_addr_t *peer_addr,
                        int32_t duration_ms, uint8_t phy_mask,
                        const struct ble_gap_conn_params *phy_1m_conn_params,
                        const struct ble_gap_conn_params *phy_2m_conn_params,
                        const struct ble_gap_conn_params *phy_coded_conn_params,
                        ble_gap_event_fn *cb, void *cb_arg);
 
#if MYNEWT_VAL(OPTIMIZE_MULTI_CONN)
int ble_gap_common_factor_set(bool enable, uint32_t common_factor);
 
int ble_gap_multi_connect(struct ble_gap_multi_conn_params *multi_conn_params,
                          ble_gap_event_fn *cb, void *cb_arg);
#endif
 
int ble_gap_conn_cancel(void);
 
int ble_gap_conn_active(void);
 
int ble_gap_terminate(uint16_t conn_handle, uint8_t hci_reason);
 
int ble_gap_wl_set(const ble_addr_t *addrs, uint8_t white_list_count);
 
int ble_gap_update_params(uint16_t conn_handle,
                          const struct ble_gap_upd_params *params);
 
int ble_gap_set_data_len(uint16_t conn_handle, uint16_t tx_octets, uint16_t tx_time);
 
int ble_gap_read_sugg_def_data_len(uint16_t *out_sugg_max_tx_octets,
                                   uint16_t *out_sugg_max_tx_time);
 
int ble_gap_write_sugg_def_data_len(uint16_t sugg_max_tx_octets, uint16_t sugg_max_tx_time);
 
int ble_gap_security_initiate(uint16_t conn_handle);
 
int ble_gap_pair_initiate(uint16_t conn_handle);
 
int ble_gap_encryption_initiate(uint16_t conn_handle, uint8_t key_size,
                                const uint8_t *ltk, uint16_t ediv,
                                uint64_t rand_val, int auth);
 
int ble_gap_conn_rssi(uint16_t conn_handle, int8_t *out_rssi);
 
int ble_gap_unpair(const ble_addr_t *peer_addr);
 
int ble_gap_unpair_oldest_peer(void);
 
int ble_gap_unpair_oldest_except(const ble_addr_t *peer_addr);
 
#define BLE_GAP_PRIVATE_MODE_NETWORK        0
#define BLE_GAP_PRIVATE_MODE_DEVICE         1
 
int ble_gap_set_priv_mode(const ble_addr_t *peer_addr, uint8_t priv_mode);
 
#define BLE_GAP_LE_PHY_1M                   1
#define BLE_GAP_LE_PHY_2M                   2
#define BLE_GAP_LE_PHY_CODED                3
int ble_gap_read_le_phy(uint16_t conn_handle, uint8_t *tx_phy, uint8_t *rx_phy);
 
#define BLE_GAP_LE_PHY_1M_MASK              0x01
#define BLE_GAP_LE_PHY_2M_MASK              0x02
#define BLE_GAP_LE_PHY_CODED_MASK           0x04
#define BLE_GAP_LE_PHY_ANY_MASK             0x0F
int ble_gap_set_prefered_default_le_phy(uint8_t tx_phys_mask,
                                        uint8_t rx_phys_mask);
 
#define BLE_GAP_LE_PHY_CODED_ANY            0
#define BLE_GAP_LE_PHY_CODED_S2             1
#define BLE_GAP_LE_PHY_CODED_S8             2
int ble_gap_set_prefered_le_phy(uint16_t conn_handle, uint8_t tx_phys_mask,
                                uint8_t rx_phys_mask, uint16_t phy_opts);
 
#if MYNEWT_VAL(BLE_CONN_SUBRATING)
int ble_gap_set_default_subrate(uint16_t subrate_min, uint16_t subrate_max, uint16_t max_latency,
                                uint16_t cont_num, uint16_t supervision_timeout);
 
int
ble_gap_subrate_req(uint16_t conn_handle, uint16_t subrate_min, uint16_t subrate_max,
                        uint16_t max_latency, uint16_t cont_num,
                        uint16_t supervision_timeout);
#endif
struct ble_gap_event_listener {
    ble_gap_event_fn *fn;
    void *arg;
    SLIST_ENTRY(ble_gap_event_listener) link;
};
 
int ble_gap_event_listener_register(struct ble_gap_event_listener *listener,
                                    ble_gap_event_fn *fn, void *arg);
 
int ble_gap_event_listener_unregister(struct ble_gap_event_listener *listener);
 
#if MYNEWT_VAL(BLE_POWER_CONTROL)
int ble_gap_set_path_loss_reporting_enable(uint16_t conn_handle, uint8_t enable);
 
int ble_gap_set_transmit_power_reporting_enable(uint16_t conn_handle,
                                                uint8_t local_enable,
                                                uint8_t remote_enable);
 
int ble_gap_enh_read_transmit_power_level(uint16_t conn_handle, uint8_t phy,
                                          uint8_t *out_status, uint8_t *out_phy,
                      uint8_t *out_curr_tx_power_level,
                      uint8_t *out_max_tx_power_level);
 
int ble_gap_read_remote_transmit_power_level(uint16_t conn_handle, uint8_t phy);
 
int ble_gap_set_path_loss_reporting_param(uint16_t conn_handle, uint8_t high_threshold,
                                          uint8_t high_hysteresis, uint8_t low_threshold,
                                          uint8_t low_hysteresis, uint16_t min_time_spent);
#endif
 
int ble_gap_set_data_related_addr_change_param(uint8_t adv_handle, uint8_t change_reason);
 
int ble_gap_dtm_tx_start(uint8_t tx_chan, uint8_t test_data_len, uint8_t payload);
 
int ble_gap_dtm_rx_start(uint8_t rx_chan);
 
int ble_gap_dtm_stop(void);
 
int ble_gap_dtm_enh_tx_start(uint8_t tx_chan, uint8_t test_data_len, uint8_t payload,
                     uint8_t phy);
 
int ble_gap_dtm_enh_rx_start(uint8_t rx_chan, uint8_t index, uint8_t phy);
 
#ifdef __cplusplus
}
#endif
 
#endif