ble_gap.h

Go to the documentation of this file.

 
#ifndef BLE_GAP_H_
#define BLE_GAP_H_
 
#include <stddef.h>
#include <stdint.h>
#include "co_version.h"
#include "co_bt.h"
#include "ble_att.h"
#include "ble_common.h"
#include "ble_config.h"
 
#define BLE_ADV_DATA_LEN_MAX      (ADV_DATA_LEN - 3)
 
        #define BLE_NON_CONN_ADV_DATA_LEN_MAX   (ADV_DATA_LEN)
 
#define BLE_SCAN_RSP_LEN_MAX      (SCAN_RSP_DATA_LEN)
 
/* Maximum length of device name in bytes (as defined by Bluetooth Core v4.2 / GAP) */
#define BLE_GAP_DEVNAME_LEN_MAX   (BD_NAME_SIZE)
 
#define BLE_GAP_CHANNEL_MAP_LEN   (LE_CHNL_MAP_LEN)
 
#define BLE_GAP_MAX_CONNECTED   (dg_configBLE_CONNECTIONS_MAX)
 
#define BLE_GAP_MAX_BONDED      (defaultBLE_MAX_BONDED)
 
#define BLE_ADV_INTERVAL_FROM_MS(MS) ((MS) * 1000 / 625)
 
#define BLE_ADV_INTERVAL_TO_MS(VAL)  ((VAL) * 625 / 1000)
 
#define BLE_SCAN_INTERVAL_FROM_MS(MS) ((MS) * 1000 / 625)
 
#define BLE_SCAN_INTERVAL_TO_MS(VAL)  ((VAL) * 625 / 1000)
 
#define BLE_SCAN_WINDOW_FROM_MS(MS) ((MS) * 1000 / 625)
 
#define BLE_SCAN_WINDOW_TO_MS(VAL)  ((VAL) * 625 / 1000)
 
#define BLE_CONN_EVENT_LENGTH_FROM_MS(MS) ((MS) * 1000 / 625)
 
#define BLE_CONN_EVENT_LENGTH_TO_MS(VAL)  ((VAL) * 625 / 1000)
 
#define BLE_CONN_INTERVAL_FROM_MS(MS) ((MS) * 100 / 125)
 
#define BLE_CONN_INTERVAL_TO_MS(VAL)  ((VAL) * 125 / 100)
 
#define BLE_SUPERVISION_TMO_FROM_MS(MS) ((MS) / 10)
 
#define BLE_SUPERVISION_TMO_TO_MS(VAL)  ((VAL) * 10)
 
#define BLE_CONN_IDX_INVALID    (0xFFFF)
 
#define BLE_RSSI_NOT_AVAILABLE  (127)
 
#define BLE_ENC_KEY_SIZE_MAX    (16)
 
typedef enum {
        BLE_GAP_APPEARANCE_UNKNOWN = 0,
        BLE_GAP_APPEARANCE_GENERIC_PHONE = 64,
        BLE_GAP_APPEARANCE_GENERIC_COMPUTER = 128,
        BLE_GAP_APPEARANCE_GENERIC_WATCH = 192,
        BLE_GAP_APPEARANCE_WATCH_SPORTS_WATCH = 193,
        BLE_GAP_APPEARANCE_GENERIC_CLOCK = 256,
        BLE_GAP_APPEARANCE_GENERIC_DISPLAY = 320,
        BLE_GAP_APPEARANCE_GENERIC_REMOTE_CONTROL = 384,
        BLE_GAP_APPEARANCE_GENERIC_EYE_GLASSES = 448,
        BLE_GAP_APPEARANCE_GENERIC_TAG = 512,
        BLE_GAP_APPEARANCE_GENERIC_KEYRING = 576,
        BLE_GAP_APPEARANCE_GENERIC_MEDIA_PLAYER = 640,
        BLE_GAP_APPEARANCE_GENERIC_BARCODE_SCANNER = 704,
        BLE_GAP_APPEARANCE_GENERIC_THERMOMETER = 768,
        BLE_GAP_APPEARANCE_THERMOMETER_EAR = 769,
        BLE_GAP_APPEARANCE_GENERIC_HEART_RATE_SENSOR = 832,
        BLE_GAP_APPEARANCE_HEART_RATE_SENSOR_HEART_RATE_BELT = 833,
        BLE_GAP_APPEARANCE_GENERIC_BLOOD_PRESSURE = 896,
        BLE_GAP_APPEARANCE_BLOOD_PRESSURE_ARM = 897,
        BLE_GAP_APPEARANCE_BLOOD_PRESSURE_WRIST = 898,
        BLE_GAP_APPEARANCE_GENERIC_HID = 960,
        BLE_GAP_APPEARANCE_HID_KEYBOARD = 961,
        BLE_GAP_APPEARANCE_HID_MOUSE = 962,
        BLE_GAP_APPEARANCE_HID_JOYSTICK = 963,
        BLE_GAP_APPEARANCE_HID_GAMEPAD = 964,
        BLE_GAP_APPEARANCE_HID_DIGITIZER_TABLET = 965,
        BLE_GAP_APPEARANCE_HID_CARD_READER = 966,
        BLE_GAP_APPEARANCE_HID_DIGITAL_PEN = 967,
        BLE_GAP_APPEARANCE_HID_BARCODE_SCANNER = 968,
        BLE_GAP_APPEARANCE_GENERIC_GLUCOSE_METER = 1024,
        BLE_GAP_APPEARANCE_GENERIC_RUNNING_WALKING_SENSOR = 1088,
        BLE_GAP_APPEARANCE_RUNNING_WALKING_SENSOR_IN_SHOE = 1089,
        BLE_GAP_APPEARANCE_RUNNING_WALKING_SENSOR_ON_SHOE = 1090,
        BLE_GAP_APPEARANCE_RUNNING_WALKING_SENSOR_ON_HIP = 1091,
        BLE_GAP_APPEARANCE_GENERIC_CYCLING = 1152,
        BLE_GAP_APPEARANCE_CYCLING_CYCLING_COMPUTER = 1153,
        BLE_GAP_APPEARANCE_CYCLING_SPEED_SENSOR = 1154,
        BLE_GAP_APPEARANCE_CYCLING_CADENCE_SENSOR = 1155,
        BLE_GAP_APPEARANCE_CYCLING_POWER_SENSOR = 1156,
        BLE_GAP_APPEARANCE_CYCLING_SPEED_AND_CADENCE_SENSOR = 1157,
        BLE_GAP_APPEARANCE_GENERIC_PULSE_OXIMETER = 3136,
        BLE_GAP_APPEARANCE_PULSE_OXIMETER_FINGERTIP = 3137,
        BLE_GAP_APPEARANCE_PULSE_OXIMETER_WRIST_WORN = 3138,
        BLE_GAP_APPEARANCE_GENERIC_WEIGHT_SCALE = 3200,
        BLE_GAP_APPEARANCE_GENERIC_OUTDOOR_SPORTS_ACTIVITY = 5184,
        BLE_GAP_APPEARANCE_OUTDOOR_SPORTS_ACT_LOCATION_DISPLAY = 5185,
        BLE_GAP_APPEARANCE_OUTDOOR_SPORTS_ACT_LOCATION_AND_NAVIGATION_DISPLAY = 5186,
        BLE_GAP_APPEARANCE_OUTDOOR_SPORTS_ACT_LOCATION_POD = 5187,
        BLE_GAP_APPEARANCE_OUTDOOR_SPORTS_ACT_LOCATION_AND_NAVIGATION_POD = 5188,
        // dummy appearance ID
        BLE_GAP_APPEARANCE_LAST,
} gap_appearance_t;
 
typedef enum {
        GAP_DATA_TYPE_FLAGS               = 0x01,
        GAP_DATA_TYPE_UUID16_LIST_INC     = 0x02,
        GAP_DATA_TYPE_UUID16_LIST         = 0x03,
        GAP_DATA_TYPE_UUID32_LIST_INC     = 0x04,
        GAP_DATA_TYPE_UUID32_LIST         = 0x05,
        GAP_DATA_TYPE_UUID128_LIST_INC    = 0x06,
        GAP_DATA_TYPE_UUID128_LIST        = 0x07,
        GAP_DATA_TYPE_SHORT_LOCAL_NAME    = 0x08,
        GAP_DATA_TYPE_LOCAL_NAME          = 0x09,
        GAP_DATA_TYPE_TX_POWER_LEVEL      = 0x0A,
        GAP_DATA_TYPE_CLASS_OF_DEVICE     = 0x0D,
        GAP_DATA_TYPE_SP_HASH_C           = 0x0E,
        GAP_DATA_TYPE_SP_RANDOMIZER_R     = 0x0F,
        GAP_DATA_TYPE_TK_VALUE            = 0x10,
        GAP_DATA_TYPE_OOB_FLAGS           = 0x11,
        GAP_DATA_TYPE_SLAVE_CONN_INTV     = 0x12,
        GAP_DATA_TYPE_UUID16_SOLIC        = 0x14,
        GAP_DATA_TYPE_UUID128_SOLIC       = 0x15,
        GAP_DATA_TYPE_UUID16_SVC_DATA     = 0x16,
        GAP_DATA_TYPE_PUBLIC_ADDRESS      = 0x17,
        GAP_DATA_TYPE_RANDOM_ADDRESS      = 0x18,
        GAP_DATA_TYPE_APPEARANCE          = 0x19,
        GAP_DATA_TYPE_ADV_INTERVAL        = 0x1A,
        GAP_DATA_TYPE_LE_BT_ADDR          = 0x1B,
        GAP_DATA_TYPE_LE_ROLE             = 0x1C,
        GAP_DATA_TYPE_SPAIR_HASH          = 0x1D,
        GAP_DATA_TYPE_SPAIR_RAND          = 0x1E,
        GAP_DATA_TYPE_UUID32_SOLIC        = 0x1F,
        GAP_DATA_TYPE_UUID32_SVC_DATA     = 0x20,
        GAP_DATA_TYPE_UUID128_SVC_DATA    = 0x21,
        GAP_DATA_TYPE_LE_SEC_CONN_CFM_VAL = 0x22,
        GAP_DATA_TYPE_LE_SEC_CONN_RAND_VAL= 0x23,
        GAP_DATA_TYPE_URI                 = 0x24,
        GAP_DATA_TYPE_INDOOR_POSITIONING  = 0x25,
        GAP_DATA_TYPE_TRANSPORT_DISC_DATA = 0x26,
        GAP_DATA_TYPE_LE_SUPP_FEATURES    = 0x27,
        GAP_DATA_TYPE_CHNL_MAP_UPD_IND    = 0x28,
        GAP_DATA_TYPE_PB_ADV              = 0x29,
        GAP_DATA_TYPE_MESH_MESSAGE        = 0x2A,
        GAP_DATA_TYPE_MESH_BEACON         = 0x2B,
        GAP_DATA_TYPE_INFO_DATA_3D        = 0x3D,
        GAP_DATA_TYPE_MANUFACTURER_SPEC   = 0xFF,
} gap_data_type_t;
 
typedef enum {
        GAP_TX_POWER_MAX          = 17,
        GAP_TX_POWER_6_dBm        = 17,
        GAP_TX_POWER_5_dBm        = 16,
        GAP_TX_POWER_4_5_dBm      = 15,
        GAP_TX_POWER_4_dBm        = 14,
        GAP_TX_POWER_3_dBm        = 13,
        GAP_TX_POWER_2_dBm        = 12,
        GAP_TX_POWER_1_5_dBm      = 11,
        GAP_TX_POWER_0_dBm        = 10,
        GAP_TX_POWER_MINUS_1_dBm  =  9,
        GAP_TX_POWER_MINUS_2_dBm  =  8,
        GAP_TX_POWER_MINUS_3_dBm  =  7,
        GAP_TX_POWER_MINUS_6_dBm  =  6,
        GAP_TX_POWER_MINUS_8_dBm  =  5,
        GAP_TX_POWER_MINUS_12_dBm =  4,
        GAP_TX_POWER_MINUS_18_dBm =  3,
        GAP_TX_POWER_MINUS_22_dBm =  2,
        GAP_TX_POWER_MINUS_26_dBm =  1,
        GAP_TX_POWER_MINUS_50_dBm =  0,
        GAP_TX_POWER_MIN          =  0,
} gap_tx_power_t;
 
enum ble_evt_gap {
        BLE_EVT_GAP_CONNECTED = BLE_EVT_CAT_FIRST(BLE_EVT_CAT_GAP),
        BLE_EVT_GAP_ADV_REPORT,
        BLE_EVT_GAP_DISCONNECTED,
        BLE_EVT_GAP_DISCONNECT_FAILED,
        BLE_EVT_GAP_ADV_COMPLETED,
        BLE_EVT_GAP_SCAN_COMPLETED,
        BLE_EVT_GAP_CONN_PARAM_UPDATE_REQ,
        BLE_EVT_GAP_CONN_PARAM_UPDATED,
        BLE_EVT_GAP_PAIR_REQ,
        BLE_EVT_GAP_PAIR_COMPLETED,
        BLE_EVT_GAP_SECURITY_REQUEST,
        BLE_EVT_GAP_PASSKEY_NOTIFY,
        BLE_EVT_GAP_PASSKEY_REQUEST,
        BLE_EVT_GAP_SEC_LEVEL_CHANGED,
        BLE_EVT_GAP_ADDRESS_RESOLVED,
        BLE_EVT_GAP_SET_SEC_LEVEL_FAILED,
        BLE_EVT_GAP_CONN_PARAM_UPDATE_COMPLETED,
        BLE_EVT_GAP_DATA_LENGTH_CHANGED,
        BLE_EVT_GAP_DATA_LENGTH_SET_FAILED,
        BLE_EVT_GAP_CONNECTION_COMPLETED,
        BLE_EVT_GAP_NUMERIC_REQUEST,
        BLE_EVT_GAP_ADDRESS_RESOLUTION_FAILED,
        BLE_EVT_GAP_LTK_MISSING,
        BLE_EVT_GAP_AIR_OP_BDADDR,
#if (dg_configBLE_2MBIT_PHY == 1)
 
        BLE_EVT_GAP_PHY_SET_COMPLETED,
        BLE_EVT_GAP_PHY_CHANGED,
#endif /* (dg_configBLE_2MBIT_PHY == 1) */
 
        BLE_EVT_GAP_PEER_VERSION,
        BLE_EVT_GAP_PEER_FEATURES,
#ifdef F_PCLE
 
        BLE_EVT_GAP_LOCAL_TX_PWR,
        BLE_EVT_GAP_TX_PWR_REPORT,
        BLE_EVT_GAP_PATH_LOSS_THRES,
#endif /* F_PCLE */
#if BLE_SSP_DEBUG
 
        BLE_EVT_GAP_LTK,
#endif
};
 
typedef struct {
         uint8_t len;           
         uint8_t type;          
         const uint8_t *data;   
} gap_adv_ad_struct_t;
 
#define GAP_ADV_AD_STRUCT(_ad_data_type, _ad_data_len, _ad_data)    \
                         { .type = (_ad_data_type),                 \
                           .len  = (_ad_data_len),                  \
                           .data = (const uint8_t *)(_ad_data) }
 
#define GAP_ADV_AD_STRUCT_BYTES(_ad_data_type, _ad_data_bytes...)                          \
                                GAP_ADV_AD_STRUCT(_ad_data_type,                           \
                                                  sizeof((uint8_t[]) { _ad_data_bytes}),   \
                                                  ((uint8_t[]) { _ad_data_bytes}))
 
#define GAP_ADV_AD_STRUCT_DECLARE(_ad_data_type, _ad_data_len, _ad_data)                     \
                                  (&(gap_adv_ad_struct_t) GAP_ADV_AD_STRUCT(_ad_data_type,   \
                                                                            _ad_data_len,    \
                                                                            _ad_data))
 
typedef struct {
        bd_address_t address;           
        uint16_t conn_idx;              
        bool connected : 1;             
        bool bonded : 1;                
        bool paired : 1;                
        bool mitm : 1;                  
#if (dg_configBLE_SECURE_CONNECTIONS == 1)
        bool secure : 1;                
#endif /* (dg_configBLE_SECURE_CONNECTIONS == 1) */
} gap_device_t;
 
typedef enum {
        GAP_DEVICE_FILTER_ALL,          
        GAP_DEVICE_FILTER_CONNECTED,    
        GAP_DEVICE_FILTER_BONDED,       
        GAP_DEVICE_FILTER_ADDRESS,      
        GAP_DEVICE_FILTER_CONN_IDX,     
} gap_device_filter_t;
 
typedef union {
        uint16_t conn_idx;              
        bd_address_t address;           
} gap_device_filter_data_t;
 
typedef struct {
        uint8_t key[16];                
} gap_sec_key_t;
 
typedef enum {
        GAP_NO_ROLE = 0x00,             
        GAP_OBSERVER_ROLE = 0x01,       
        GAP_BROADCASTER_ROLE = 0x02,    
        GAP_CENTRAL_ROLE = 0x04,        
        GAP_PERIPHERAL_ROLE = 0x08,     
        GAP_ALL_ROLES = (GAP_OBSERVER_ROLE|GAP_BROADCASTER_ROLE|GAP_CENTRAL_ROLE|GAP_PERIPHERAL_ROLE),  
} gap_role_t;
 
typedef struct gap_chnl_map {
        uint8_t   map[BLE_GAP_CHANNEL_MAP_LEN]; 
} gap_chnl_map_t;
 
typedef enum {
        GAP_AIR_OP_ADV      = 0x01,     
        GAP_AIR_OP_SCAN     = 0x02,     
        GAP_AIR_OP_INITIATE = 0x04,     
} gap_air_op_t;
 
typedef enum {
        GAP_CONN_MODE_NON_CONN,         
        GAP_CONN_MODE_UNDIRECTED,       
        GAP_CONN_MODE_DIRECTED,         
        GAP_CONN_MODE_DIRECTED_LDC,     
} gap_conn_mode_t;
 
typedef enum {
        GAP_DISC_MODE_NON_DISCOVERABLE, 
        GAP_DISC_MODE_GEN_DISCOVERABLE, 
        GAP_DISC_MODE_LIM_DISCOVERABLE, 
        GAP_DISC_MODE_BROADCASTER,      
} gap_disc_mode_t;
 
typedef enum {
        GAP_ADV_CHANNEL_37  = 0x01,     
        GAP_ADV_CHANNEL_38  = 0x02,     
        GAP_ADV_CHANNEL_39  = 0x04,     
} gap_adv_chnl_t;
 
typedef enum {
        ADV_ALLOW_SCAN_ANY_CONN_ANY,    
        ADV_ALLOW_SCAN_WLIST_CONN_ANY,  
        ADV_ALLOW_SCAN_ANY_CONN_WLIST,  
        ADV_ALLOW_SCAN_WLIST_CONN_WLIST,
} adv_filt_pol_t;
 
enum {
        GAP_ADV_IND,                    
        GAP_ADV_DIRECT_IND,             
        GAP_ADV_SCAN_IND,               
        GAP_ADV_NONCONN_IND,            
        GAP_SCAN_RSP,                   
};
 
typedef enum {
        GAP_SCAN_ACTIVE,                
        GAP_SCAN_PASSIVE,               
} gap_scan_type_t;
 
typedef enum {
        GAP_SCAN_GEN_DISC_MODE,         
        GAP_SCAN_LIM_DISC_MODE,         
        GAP_SCAN_OBSERVER_MODE,         
} gap_scan_mode_t;
 
typedef enum {
        GAP_AUTH_NO_MITM_NO_BOND = 0x00, 
        GAP_AUTH_NO_MITM_BOND    = 0x01, 
        GAP_AUTH_MITM_NO_BOND    = 0x04, 
        GAP_AUTH_MITM_BOND       = 0x05, 
} gap_auth_t;
 
typedef enum {
        GAP_SEC_LEVEL_1         = 0x00, 
        GAP_SEC_LEVEL_2         = 0x01, 
        GAP_SEC_LEVEL_3         = 0x02, 
        GAP_SEC_LEVEL_4         = 0x03, 
 
} gap_sec_level_t;
 
typedef enum {
        GAP_IO_CAP_DISP_ONLY           = 0x00, 
        GAP_IO_CAP_DISP_YES_NO         = 0x01, 
        GAP_IO_CAP_KEYBOARD_ONLY       = 0x02, 
        GAP_IO_CAP_NO_INPUT_OUTPUT     = 0x03, 
        GAP_IO_CAP_KEYBOARD_DISP       = 0x04, 
} gap_io_cap_t;
 
typedef enum {
        BLE_GAP_PHY_1M    = 0x01,    
        BLE_GAP_PHY_2M    = 0x02,    
        BLE_GAP_PHY_CODED = 0x03,    
} ble_gap_phy_t;
 
typedef enum {
        BLE_GAP_PHY_PREF_AUTO  = 0x00,    
        BLE_GAP_PHY_PREF_1M    = 0x01,    
        BLE_GAP_PHY_PREF_2M    = 0x02,    
        BLE_GAP_PHY_PREF_CODED = 0x04,    
} ble_gap_phy_pref_t;
 
#ifdef F_PCLE
 
typedef enum {
        BLE_GAP_LOCAL_TX_PWR         = 0x00,    
        BLE_GAP_REMOTE_TX_PWR        = 0x01,    
        BLE_GAP_ENH_LOCAL_TX_PWR_CMD = 0x02,    
} ble_gap_reason_t;
#endif /* F_PCLE */
 
typedef struct {
        uint16_t interval_min;                          
        uint16_t interval_max;                          
        uint16_t slave_latency;                         
        uint16_t sup_timeout;                           
} gap_conn_params_t;
 
typedef struct {
        uint16_t interval;                              
        uint16_t window;                                
} gap_scan_params_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        bd_address_t       own_addr;                    
        bd_address_t       peer_address;                
        gap_conn_params_t  conn_params;                 
} ble_evt_gap_connected_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        bd_address_t       address;                     
        uint8_t            reason;                      
} ble_evt_gap_disconnected_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        uint8_t            status;                      
} ble_evt_gap_disconnect_failed_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        gap_conn_params_t  conn_params;                 
} ble_evt_gap_conn_param_update_req_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        uint8_t            status;                      
} ble_evt_gap_conn_param_update_completed_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        gap_conn_params_t  conn_params;                 
} ble_evt_gap_conn_param_updated_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint8_t            adv_type;                    
        uint8_t            status;                      
} ble_evt_gap_adv_completed_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint8_t            type;                        
        bd_address_t       address;                     
        int8_t             rssi;                        
        uint8_t            length;                      
        uint8_t            data[BLE_ADV_DATA_LEN_MAX];  
} ble_evt_gap_adv_report_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint8_t            scan_type;                   
        uint8_t            status;                      
} ble_evt_gap_scan_completed_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        bool               bond;                        
} ble_evt_gap_pair_req_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        uint8_t            status;                      
        bool               bond;                        
        bool               mitm;                        
} ble_evt_gap_pair_completed_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        bool               bond;                        
        bool               mitm;                        
} ble_evt_gap_security_request_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        uint32_t           passkey;                     
} ble_evt_gap_passkey_notify_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
} ble_evt_gap_passkey_request_t;
 
#if (dg_configBLE_SECURE_CONNECTIONS == 1)
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        uint32_t           num_key;                     
} ble_evt_gap_numeric_request_t;
#endif /* (dg_configBLE_SECURE_CONNECTIONS == 1) */
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        bd_address_t       resolved_address;            
        bd_address_t       address;                     
} ble_evt_gap_address_resolved_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           status;                      
} ble_evt_gap_address_resolution_failed_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        gap_sec_level_t    level;                       
} ble_evt_gap_sec_level_changed_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        ble_error_t        status;                      
} ble_evt_gap_set_sec_level_failed_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        uint16_t           max_rx_length;               
        uint16_t           max_rx_time;                 
        uint16_t           max_tx_length;               
        uint16_t           max_tx_time;                 
} ble_evt_gap_data_length_changed_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        uint16_t           status;                      
} ble_evt_gap_data_length_set_failed_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint8_t            status;                      
} ble_evt_gap_connection_completed_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
} ble_evt_gap_ltk_missing_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        own_address_t      address;                     
} ble_evt_gap_air_op_bdaddr_t;
 
#if (dg_configBLE_2MBIT_PHY == 1)
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        uint16_t           status;                      
} ble_evt_gap_phy_set_completed_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        ble_gap_phy_t      tx_phy;                      
        ble_gap_phy_t      rx_phy;                      
} ble_evt_gap_phy_changed_t;
#endif /* (dg_configBLE_2MBIT_PHY == 1) */
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        uint8_t            lmp_version;                 
        uint16_t           company_id;                  
        uint16_t           lmp_subversion;              
} ble_evt_gap_peer_version_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        uint8_t            le_features[LE_FEATS_LEN];   
} ble_evt_gap_peer_features_t;
#ifdef F_PCLE
 
typedef struct {
        ble_evt_hdr_t       hdr;                        
        uint16_t            conn_idx;                   
        ble_error_t         status;                     
        uint8_t             phy;                        
        int8_t              curr_tx_pwr_lvl;            
        int8_t              max_tx_pwr_lvl;             
 
} ble_evt_gap_local_tx_pwr_t;
 
typedef struct {
        ble_evt_hdr_t       hdr;                        
        uint16_t            conn_idx;                   
        ble_error_t         status;                     
        ble_gap_reason_t    reason;                     
        uint8_t             phy;                        
        int8_t              tx_pwr_lvl;                 
        uint8_t             tx_pwr_lvl_flag;            
        int8_t              delta;                      
} ble_evt_gap_tx_pwr_report_t;
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        uint8_t            curr_path_loss;              
        uint8_t            zone_enter;                  
} ble_evt_gap_path_loss_thres_t;
#endif /* F_PCLE */
 
#if BLE_SSP_DEBUG
 
typedef struct {
        ble_evt_hdr_t      hdr;                         
        uint16_t           conn_idx;                    
        gap_sec_key_t      ltk;                         
} ble_evt_gap_ltk_t;
#endif
 
ble_error_t ble_gap_address_get(own_address_t *address);
 
ble_error_t ble_gap_address_set(const own_address_t *address, uint16_t renew_dur);
 
ble_error_t ble_gap_device_name_set(const char *name, att_perm_t perm);
 
ble_error_t ble_gap_device_name_get(char *name, uint8_t *length);
 
ble_error_t ble_gap_appearance_set(gap_appearance_t appearance, att_perm_t perm);
 
ble_error_t ble_gap_appearance_get(gap_appearance_t *appearance);
 
ble_error_t ble_gap_per_pref_conn_params_set(const gap_conn_params_t *conn_params);
 
ble_error_t ble_gap_per_pref_conn_params_get(gap_conn_params_t *conn_params);
 
ble_error_t ble_gap_adv_start(gap_conn_mode_t adv_type);
 
ble_error_t ble_gap_adv_stop(void);
 
ble_error_t ble_gap_adv_data_set(uint8_t adv_data_len, const uint8_t *adv_data,
                                 uint8_t scan_rsp_data_len, const uint8_t *scan_rsp_data);
 
ble_error_t ble_gap_adv_ad_struct_set(size_t ad_len, const gap_adv_ad_struct_t *ad, size_t sd_len,
                                                                    const gap_adv_ad_struct_t *sd);
 
ble_error_t ble_gap_adv_data_get(uint8_t *adv_data_len, uint8_t *adv_data,
                                 uint8_t *scan_rsp_data_len, uint8_t *scan_rsp_data);
 
ble_error_t ble_gap_adv_intv_get(uint16_t *adv_intv_min, uint16_t *adv_intv_max);
 
ble_error_t ble_gap_adv_intv_set(uint16_t adv_intv_min, uint16_t adv_intv_max);
 
ble_error_t ble_gap_adv_chnl_map_get(uint8_t *chnl_map);
 
ble_error_t ble_gap_adv_chnl_map_set(uint8_t chnl_map);
 
ble_error_t ble_gap_adv_mode_get(gap_disc_mode_t *adv_mode);
 
ble_error_t ble_gap_adv_mode_set(gap_disc_mode_t adv_mode);
 
ble_error_t ble_gap_adv_filt_policy_get(adv_filt_pol_t *filt_policy);
 
ble_error_t ble_gap_adv_filt_policy_set(adv_filt_pol_t filt_policy);
 
ble_error_t ble_gap_adv_direct_address_get(bd_address_t *address);
 
ble_error_t ble_gap_adv_direct_address_set(const bd_address_t *address);
 
ble_error_t ble_gap_adv_set_permutation(uint8_t permutation_index);
 
ble_error_t ble_gap_scan_start(gap_scan_type_t type, gap_scan_mode_t mode, uint16_t interval,
                               uint16_t window, bool filt_wlist, bool filt_dupl);
 
ble_error_t ble_gap_scan_stop(void);
 
ble_error_t ble_gap_scan_params_get(gap_scan_params_t *scan_params);
 
ble_error_t ble_gap_scan_params_set(const gap_scan_params_t *scan_params);
 
ble_error_t ble_gap_connect(const bd_address_t *peer_addr, const gap_conn_params_t *conn_params);
 
ble_error_t ble_gap_connect_ce(const bd_address_t *peer_addr, const gap_conn_params_t *conn_params,
                               uint16_t ce_len_min, uint16_t ce_len_max);
ble_error_t ble_gap_connect_cancel(void);
 
ble_error_t ble_gap_disconnect(uint16_t conn_idx, ble_hci_error_t reason);
 
ble_error_t ble_gap_peer_version_get(uint16_t conn_idx);
 
ble_error_t ble_gap_peer_features_get(uint16_t conn_idx);
 
ble_error_t ble_gap_conn_rssi_get(uint16_t conn_idx, int8_t *conn_rssi);
 
ble_error_t ble_gap_role_get(gap_role_t *role);
 
ble_error_t ble_gap_role_set(const gap_role_t role);
 
ble_error_t ble_gap_mtu_size_get(uint16_t *mtu_size);
 
ble_error_t ble_gap_mtu_size_set(uint16_t mtu_size);
 
ble_error_t ble_gap_channel_map_get(uint64_t *chnl_map);
 
ble_error_t ble_gap_channel_map_set(const uint64_t chnl_map);
 
ble_error_t ble_gap_conn_param_update(uint16_t conn_idx, const gap_conn_params_t *conn_params);
 
ble_error_t ble_gap_conn_param_update_reply(uint16_t conn_idx, bool accept);
 
ble_error_t ble_gap_pair(uint16_t conn_idx, bool bond);
 
ble_error_t ble_gap_pair_reply(uint16_t conn_idx, bool accept, bool bond);
 
ble_error_t ble_gap_get_connected(uint8_t *length, uint16_t **conn_idx);
 
ble_error_t ble_gap_get_bonded(uint8_t *length, bd_address_t **addr);
 
ble_error_t ble_gap_get_io_cap(gap_io_cap_t *io_cap);
 
ble_error_t ble_gap_set_io_cap(gap_io_cap_t io_cap);
 
ble_error_t ble_gap_passkey_reply(uint16_t conn_idx, bool accept, uint32_t passkey);
 
#if (dg_configBLE_SECURE_CONNECTIONS == 1)
 
ble_error_t ble_gap_numeric_reply(uint16_t conn_idx, bool accept);
#endif /* (dg_configBLE_SECURE_CONNECTIONS == 1) */
 
ble_error_t ble_gap_get_sec_level(uint16_t conn_idx, gap_sec_level_t *level);
 
ble_error_t ble_gap_unpair(const bd_address_t *addr);
 
ble_error_t ble_gap_set_sec_level(uint16_t conn_idx, gap_sec_level_t level);
 
ble_error_t ble_gap_get_devices(gap_device_filter_t filter, gap_device_filter_data_t *filter_data,
                                                        size_t *length, gap_device_t *gap_devices);
 
ble_error_t ble_gap_get_device_by_addr(const bd_address_t *addr, gap_device_t *gap_device);
 
ble_error_t ble_gap_get_device_by_conn_idx(uint16_t conn_idx, gap_device_t *gap_device);
 
ble_error_t ble_gap_is_bonded(uint16_t conn_idx, bool *bonded);
 
ble_error_t ble_gap_is_addr_bonded(const bd_address_t *addr, bool *bonded);
 
 
ble_error_t ble_gap_data_length_set(uint16_t conn_idx, uint16_t tx_length, uint16_t tx_time);
 
ble_error_t ble_gap_address_resolve(bd_address_t address);
 
#if (dg_configBLE_2MBIT_PHY == 1)
 
ble_error_t ble_gap_phy_get(uint16_t conn_idx, uint8_t *tx_phy, uint8_t *rx_phy);
 
ble_error_t ble_gap_phy_set(uint16_t conn_idx, uint8_t tx_phy, uint8_t rx_phy);
#endif /* (dg_configBLE_2MBIT_PHY == 1) */
 
ble_error_t ble_gap_tx_power_set(uint8_t air_operation, gap_tx_power_t tx_power);
 
ble_error_t ble_gap_conn_tx_power_set(uint16_t conn_idx, gap_tx_power_t tx_power);
 
#ifdef F_PCLE
 
ble_error_t ble_gap_local_tx_power_get(uint16_t conn_idx, uint8_t phy);
 
ble_error_t ble_gap_remote_tx_power_get(uint16_t conn_idx, uint8_t phy);
 
ble_error_t ble_gap_path_loss_report_params_set(uint16_t conn_idx, uint8_t high_thres, uint8_t high_hyst,
                                                uint8_t low_thres, uint8_t low_hyst, uint16_t min_time_spent);
 
ble_error_t ble_gap_path_loss_report_en(uint16_t conn_idx, bool enable);
 
ble_error_t ble_gap_tx_power_report_en(uint16_t conn_idx, bool local_enable, bool remote_enable);
 
ble_error_t ble_gap_rf_path_compensation_set(int16_t rf_tx_path_compens, int16_t rf_rx_path_compens);
 
#endif /* F_PCLE */
 
#endif /* BLE_GAP_H_ */