in_ble_gap.h

#ifndef IN_BLE_GAP_H
#define IN_BLE_GAP_H

#include <stdint.h>
#include <stdbool.h>
/*
 * DEFINES
 ****************************************************************************************
 */

#define BLE_BDADDR_LEN       (6)
#define BLE_CHNL_MAP_LEN   (0x05)
#define BLE_FEATS_LEN      (0x08)
#define BLE_ADV_DATA_LEN      (0x1F)
#define BLE_SCAN_RSP_DATA_LEN (0x1F)
#define BLE_RAND_NB_LEN       (0x08)
#define BLE_KEY_LEN           (16)
#define BLE_P256_KEY_LEN      (0x20)

#define GAP_CNX_INTERVAL_MIN            6       //(0x06)
#define GAP_CNX_INTERVAL_MAX            3200    //(0xC80)
#define GAP_CNX_LATENCY_MIN             0       //(0x00)
#define GAP_CNX_LATENCY_MAX             499     //(0x1F3)
#define GAP_CNX_SUP_TO_MIN              10      //(0x0A)
#define GAP_CNX_SUP_TO_MAX              3200    //(0xC80)

#define ADDR_PRAND_LEN            (3)
#define ADDR_HASH_LEN             (3)

/*
 * DEFINES - Optional for BLE application usage
 ****************************************************************************************
 */

#define GAP_TMR_CONN_PAUSE_CT                               0x0064

#define GAP_TMR_CONN_PAUSE_PH                               0x01F4

#define GAP_TMR_SCAN_FAST_PERIOD                            0x0C00

#define GAP_TMR_ADV_FAST_PERIOD                             0x0BB8

#define GAP_LIM_DISC_SCAN_INT                               0x0012

#define GAP_SCAN_FAST_INTV                                  0x0030

#define GAP_SCAN_FAST_WIND                                  0x0030

#define GAP_SCAN_SLOW_INTV1                                 0x00CD

#define GAP_SCAN_SLOW_INTV2                                 0x019A

#define GAP_SCAN_SLOW_WIND1                                 0x0012

#define GAP_SCAN_SLOW_WIND2                                 0x0024

#define GAP_ADV_FAST_INTV1                                  0x0030

#define GAP_ADV_FAST_INTV2                                  0x0064

#define GAP_ADV_SLOW_INTV                                   0x00B0

#define GAP_INIT_CONN_MIN_INTV                              0x0018
#define GAP_INIT_CONN_MAX_INTV                              0x0028

#define GAP_CONN_SUPERV_TIMEOUT                             0x07D0

#define GAP_CONN_MIN_CE                                     0x0000

#define GAP_CONN_MAX_CE                                     0xFFFF

#define GAP_CONN_LATENCY                                    0x0000

#define GAP_APPEARANCE                                      0x0000

#define GAP_PPCP_CONN_INTV_MAX                              0x0064
#define GAP_PPCP_CONN_INTV_MIN                              0x00C8
#define GAP_PPCP_SLAVE_LATENCY                              0x0000
#define GAP_PPCP_STO_MULT                                   0x07D0

/*
 * Enumerations
 ****************************************************************************************
 */
enum ble_ad_type
{
    AD_TYPE_FLAGS                      = 0x01,
    AD_TYPE_MORE_16_BIT_UUID           = 0x02,
    AD_TYPE_COMPLETE_LIST_16_BIT_UUID  = 0x03,
    AD_TYPE_MORE_32_BIT_UUID           = 0x04,
    AD_TYPE_COMPLETE_LIST_32_BIT_UUID  = 0x05,
    AD_TYPE_MORE_128_BIT_UUID          = 0x06,
    AD_TYPE_COMPLETE_LIST_128_BIT_UUID = 0x07,
    AD_TYPE_SHORTENED_NAME             = 0x08,
    AD_TYPE_COMPLETE_NAME              = 0x09,
    AD_TYPE_TRANSMIT_POWER             = 0x0A,
    AD_TYPE_CLASS_OF_DEVICE            = 0x0D,
    AD_TYPE_SP_HASH_C                  = 0x0E,
    AD_TYPE_SP_RANDOMIZER_R            = 0x0F,
    AD_TYPE_TK_VALUE                   = 0x10,
    AD_TYPE_OOB_FLAGS                  = 0x11,
    AD_TYPE_SLAVE_CONN_INT_RANGE       = 0x12,
    AD_TYPE_RQRD_16_BIT_SVC_UUID       = 0x14,
    AD_TYPE_RQRD_32_BIT_SVC_UUID       = 0x1F,
    AD_TYPE_RQRD_128_BIT_SVC_UUID      = 0x15,
    AD_TYPE_SERVICE_16_BIT_DATA        = 0x16,
    AD_TYPE_SERVICE_32_BIT_DATA        = 0x20,
    AD_TYPE_SERVICE_128_BIT_DATA       = 0x21,
    AD_TYPE_PUB_TGT_ADDR               = 0x17,
    AD_TYPE_RAND_TGT_ADDR              = 0x18,
    AD_TYPE_APPEARANCE                 = 0x19,
    AD_TYPE_ADV_INTV                   = 0x1A,
    AD_TYPE_LE_BT_ADDR                 = 0x1B,
    AD_TYPE_LE_ROLE                    = 0x1C,
    AD_TYPE_SPAIR_HASH                 = 0x1D,
    AD_TYPE_SPAIR_RAND                 = 0x1E,
    AD_TYPE_3D_INFO                    = 0x3D,

    AD_TYPE_MANU_SPECIFIC_DATA         = 0xFF,
};

enum ble_rnd_addr_type
{
    STATIC_ADDR     = 0xC0,
    NON_RSLV_ADDR   = 0x00,
    RSLV_ADDR       = 0x40,
};

enum ble_role
{
    ROLE_NONE        = 0x00,

    ROLE_OBSERVER    = 0x01,

    ROLE_BROADCASTER = 0x02,

    ROLE_CENTRAL     = (0x04 | ROLE_OBSERVER),

    ROLE_PERIPHERAL  = (0x08 | ROLE_BROADCASTER),

    ROLE_ALL         = (ROLE_CENTRAL | ROLE_PERIPHERAL),
};

enum ble_io_cap
{
    IO_CAP_DISPLAY_ONLY = 0x00,
    IO_CAP_DISPLAY_YES_NO,
    IO_CAP_KB_ONLY,
    IO_CAP_NO_INPUT_NO_OUTPUT,
    IO_CAP_KB_DISPLAY,
    IO_CAP_LAST
};

enum ble_tk_type
{
    TK_OOB         = 0x00,
    TK_DISPLAY,
    TK_KEY_ENTRY
};

enum ble_oob
{
    OOB_AUTH_DATA_NOT_PRESENT = 0x00,
    OOB_AUTH_DATA_PRESENT,
    OOB_AUTH_DATA_LAST
};

enum ble_auth_mask
{
    AUTH_NONE    = 0,
    AUTH_BOND    = (1 << 0),
    AUTH_MITM    = (1 << 2),
    AUTH_SEC_CON = (1 << 3),
    AUTH_KEY_NOTIF = (1 << 4)
};

enum ble_lk_sec_lvl
{
    LK_NO_AUTH             = 0,
    LK_UNAUTH,
    LK_AUTH,
    LK_SEC_CON,
};

enum ble_auth
{
    AUTH_REQ_NO_MITM_NO_BOND  = (AUTH_NONE),
    AUTH_REQ_NO_MITM_BOND     = (AUTH_BOND),
    AUTH_REQ_MITM_NO_BOND     = (AUTH_MITM),
    AUTH_REQ_MITM_BOND        = (AUTH_MITM | AUTH_BOND),
    AUTH_REQ_SEC_CON_NO_BOND  = (AUTH_SEC_CON),
    AUTH_REQ_SEC_CON_BOND     = (AUTH_SEC_CON | AUTH_BOND),
    AUTH_REQ_SEC_CON_MITM_BOND      = (AUTH_SEC_CON | AUTH_BOND | AUTH_MITM),
    AUTH_REQ_LAST,

    AUTH_REQ_MASK             = 0x1F,
};

enum ble_kdist
{
    KDIST_NONE = 0x00,
    KDIST_ENCKEY = (1 << 0),
    KDIST_IDKEY  = (1 << 1),
    KDIST_SIGNKEY= (1 << 2),
    KDIST_LINKKEY=   (1 << 3),

    KDIST_LAST =   (1 << 4)
};

enum ble_sec_req
{
    NO_SEC = 0x00,
    SEC1_NOAUTH_PAIR_ENC,
    SEC1_AUTH_PAIR_ENC,
    SEC2_NOAUTH_DATA_SGN,
    SEC2_AUTH_DATA_SGN,
    SEC1_SEC_CON_PAIR_ENC,
};

enum ble_phy
{
    PHY_ANY               = 0x00,
    PHY_LE_1MBPS          = (1 << 0),
    PHY_LE_2MBPS          = (1 << 1),
    PHY_LE_CODED          = (1 << 2),
};

enum ble_phy_value
{
    PHY_UNDEF_LNK_VALUE    = 0,
    PHY_1MBPS_LNK_VALUE    = 1,
    PHY_2MBPS_LNK_VALUE    = 2,
    PHY_CODED_LNK_VALUE    = 3,
};

enum ble_test_mode
{
    TEST_MODE_STOP = 1,
    TEST_MODE_RX,
    TEST_MODE_TX,
};

enum ble_test_phy
{
    TEST_PHY_1MBPS        = 1,
    TEST_PHY_2MBPS        = 2,
    TEST_PHY_CODED        = 3,
    TEST_PHY_125KBPS      = 3,
    TEST_PHY_500KBPS      = 4,
};

enum ble_modulation_idx
{
    MODULATION_STANDARD,
    MODULATION_STABLE,
};

enum ble_pkt_pld_type
{
    PKT_PLD_PRBS9,
    PKT_PLD_REPEATED_11110000,
    PKT_PLD_REPEATED_10101010,
    PKT_PLD_PRBS15,
    PKT_PLD_REPEATED_11111111,
    PKT_PLD_REPEATED_00000000,
    PKT_PLD_REPEATED_00001111,
    PKT_PLD_REPEATED_01010101,
};

enum ble_priv_cfg
{
    PRIV_CFG_PRIV_ADDR_BIT = (1 << 0),
    PRIV_CFG_RSVD          = (1 << 1),
    PRIV_CFG_PRIV_EN_BIT   = (1 << 2),
};

enum ble_pairing_mode
{
    PAIRING_DISABLE  = 0,
    PAIRING_LEGACY   = (1 << 0),
    PAIRING_SEC_CON  = (1 << 1),

    PAIRING_FORCE_P256_KEY_GEN = (1<<7),
};

enum ble_write_att_perm
{
    WRITE_DISABLE     = 0,
    WRITE_NO_AUTH     = 1,
    WRITE_UNAUTH      = 2,
    WRITE_AUTH        = 3,
    WRITE_SEC_CON     = 4
};

enum ble_get_dev_info_cmd {
    GET_DEV_INFO_VERSION,
    GET_DEV_INFO_BDADDR,        
    GET_DEV_INFO_TX_POWER,  
    GET_DEV_INFO_ADV_TX_POWER,  
    GET_DEV_INFO_SUGG_DFT_DATA, 
    GET_DEV_INFO_SUPP_DFT_DATA, 
    GET_DEV_INFO_MAX_ADV_DATA_LEN,  
    GET_DEV_INFO_WLIST_SIZE,        
    GET_DEV_INFO_RAL_SIZE,  
    GET_DEV_INFO_PAL_SIZE,  
    GET_DEV_INFO_NB_ADV_SETS,       
};

enum ble_actv_type
{
    ACTV_TYPE_ADV = 0,
    ACTV_TYPE_SCAN,
    ACTV_TYPE_INIT,
    ACTV_TYPE_PER_SYNC,
};

enum adv_report_type
{
    REPORT_TYPE_ADV_EXT = 0,
    REPORT_TYPE_ADV_LEG,
    REPORT_TYPE_SCAN_RSP_EXT,
    REPORT_TYPE_SCAN_RSP_LEG,
    REPORT_TYPE_PER_ADV,
};

enum ble_adv_report_info
{
    REPORT_INFO_REPORT_TYPE_MASK    = 0x07,
    REPORT_INFO_COMPLETE_BIT        = (1 << 3),
    REPORT_INFO_CONN_ADV_BIT        = (1 << 4),
    REPORT_INFO_SCAN_ADV_BIT        = (1 << 5),
    REPORT_INFO_DIR_ADV_BIT         = (1 << 6),
};

enum ble_adv_type
{
    ADV_TYPE_LEGACY = 0,    
    ADV_TYPE_EXTENDED,      
    ADV_TYPE_PERIODIC,
};      


enum ble_adv_disc_mode
{
    ADV_MODE_NON_DISC = 0,  
    ADV_MODE_GEN_DISC,  
    ADV_MODE_LIM_DISC,
    ADV_MODE_BEACON,
};

enum ble_adv_prop
{
    ADV_PROP_CONNECTABLE = 0x01,
    ADV_PROP_SCANNABLE = 0x02,
    ADV_PROP_DIRECTED   = 0x04,
    ADV_PROP_HDC = 0x08,
    ADV_PROP_ANONYMOUS = 0x20,                  
    ADV_PROP_TX_PWR = 0x40,
    ADV_PROP_PER_TX_PWR = 0x80,
    ADV_PROP_SCAN_REQ_NTF_EN = 0x100,   
    ADV_PROP_NO_ADV_DATA = 0x200    
};

enum ble_adv_legacy_prop
{
    ADV_PROP_NON_CONN_NON_SCAN = 0x00,  
    ADV_PROP_BROADCAST_NON_SCAN = 0x00,
    ADV_PROP_NON_CONN_SCAN = ADV_PROP_SCANNABLE,        
    ADV_PROP_BROADCAST_SCAN = ADV_PROP_NON_CONN_SCAN,       
    ADV_PROP_UNDIR_CONN =   ADV_PROP_CONNECTABLE | ADV_PROP_SCANNABLE,  
    ADV_PROP_DIR_CONN = ADV_PROP_DIRECTED | ADV_PROP_CONNECTABLE,       
    ADV_PROP_DIR_CONN_LDC = ADV_PROP_DIR_CONN,  
    ADV_PROP_DIR_CONN_HDC = ADV_PROP_DIR_CONN | ADV_PROP_HDC,   
};

enum ble_adv_ext_prop
{
    EXT_ADV_PROP_NON_CONN_NON_SCAN = 0x00,      
    EXT_ADV_PROP_NON_CONN_SCAN = ADV_PROP_SCANNABLE,    
    EXT_ADV_PROP_NON_CONN_SCAN_DIR = ADV_PROP_SCANNABLE | ADV_PROP_DIRECTED,    
    EXT_ADV_PROP_ANONYM_DIR = ADV_PROP_ANONYMOUS | ADV_PROP_DIRECTED,       
    EXT_ADV_PROP_UNDIR_CONN = ADV_PROP_CONNECTABLE,     
    EXT_ADV_PROP_DIR_CONN = ADV_PROP_CONNECTABLE | ADV_PROP_DIRECTED,       
    EXT_ADV_PROP_NON_CONN_NON_SCAN_NON_ADV_DATA = ADV_PROP_NO_ADV_DATA,
};  

enum ble_adv_per_prop
{
    PER_ADV_PROP_UNDIR = 0x00,      
    PER_ADV_PROP_DIR = ADV_PROP_DIRECTED        
};

enum ble_adv_filt_pol 
{
    ADV_FILT_ALLOW_SCAN_ANY_CON_ANY = 0,
    ADV_FILT_ALLOW_SCAN_WLST_CON_ANY,   
    ADV_FILT_ALLOW_SCAN_ANY_CON_WLST,
    ADV_FILT_ALLOW_SCAN_WLST_CON_WLST,
};  

enum ble_adv_chnl
{
    CHANNEL_37 = 0x01,
    CHANNEL_38 = 0x02,
    CHANNEL_39 = 0x04,
};

enum ble_addr_type
{
    ADDR_STATIC,
    ADDR_RESOLVABLE,
    ADDR_NON_RESOLVABLE,
};

enum ble_scan_type
{
    GEN_DISC = 0,
    LIM_DISC,   
    OBSERVER,   
    SEL_OBSERVER,   
    CONN_DISC,
    SEL_CONN_DISC,
};

enum ble_scan_prop
{
    SCAN_PROP_PHY_1M = 0x01,    
    SCAN_PROP_PHY_CODED = 0x02, 
    SCAN_PROP_ACTIVE_1M = 0x04, 
    SCAN_PROP_ACTIVE_CODED = 0x08,  
    SCAN_PROP_ACCEPT_RPA = 0x10,
    SCAN_PROP_FILT_TRUNC = 0x20,
};      

enum ble_scan_dup_filt
{
    DUPLIC_DIS = 0,
    DUPLIC_EN,
    DUPLIC_EN_PER_PERIOD,
};

enum ble_initiator_type
{
    INIT_TYPE_DIRECT_CONN_EST = 0,
    INIT_TYPE_AUTO_CONN_EST,
    INIT_TYPE_NAME_DISC,
};

enum ble_initiator_prop
{
    INIT_PROP_1M = 0x01,
    INIT_PROP_2M = 0x02,
    INIT_PROP_CODED = 0x04,
};

enum ble_per_sync_type
{
    PER_SYNC_TYPE_GENERAL = 0,  
    PER_SYNC_TYPE_SELECTIVE,
};

enum ble_coded_phy_opt {
    PHY_OPT_NO_CODED_TX_PREF,
    PHY_OPT_S2_CODED_TX_PREF,
    PHY_OPT_S8_CODED_TX_PREF,
};

enum ble_keypress_state {
    PASSKEY_ENTRY_STARTED = 0,  
    PASSKEY_DIGIT_ENTERED,
    PASSKEY_DIGIT_ERASED    ,
    PASSKEY_CLEARED ,
    PASSKEY_ENTRY_COMPLETED,
};  

enum ble_bond
{
    PAIRING_REQ,
    PAIRING_RSP,

    PAIRING_SUCCEED,
    PAIRING_FAILED,

    TK_EXCH,
    IRK_EXCH,
    CSRK_EXCH,
    LTK_EXCH,

    REPEATED_ATTEMPT,

    OOB_EXCH,

    NC_EXCH
};

enum ble_clk_acc
{
    CLK_ACC_500 = 0,
    CLK_ACC_250,
    CLK_ACC_150,
    CLK_ACC_100,
    CLK_ACC_75,
    CLK_ACC_50,
    CLK_ACC_30,
    CLK_ACC_20,
};

enum ble_disc_reason {
    DISC_REASON_AUTH_FAILURE =  0x05,
    DISC_REASON_REMOTE_USER_TERM_CON = 0x13,
    DISC_REASON_REMOTE_DEV_TERM_LOW_RESOURCES = 0x14,
    DISC_REASON_REMOTE_DEV_POWER_OFF = 0x15,
    DISC_REASON_UNSUPPORTED_REMOTE_FEATURE = 0x1A,      
    DISC_REASON_PAIRING_WITH_UNIT_KEY_NOT_SUPP = 0x29,      
    DISC_REASON_UNACCEPTABLE_CONN_INT = 0x3B,
};


/*@TRACE*/
enum ble_dev_info
{
   DEV_NAME,
    DEV_APPEARANCE,
    DEV_SLV_PREF_PARAMS,
    DEV_CTL_ADDR_RESOL,
    DEV_INFO_MAX,
};
/*************** GAP Structures ********************/

typedef struct 
{
    uint16_t length;
    uint8_t value[249];
} ble_dev_name_t;

typedef struct {
    uint8_t hci_ver;
    uint8_t lmp_ver;
    uint8_t host_ver;
    uint16_t hci_subver;
    uint16_t lmp_subver;
    uint16_t host_subver;
    uint16_t manuf_name;
} ble_dev_verison_t;

typedef struct 
{
    uint16_t compid;
    uint16_t lmp_subvers;
    uint8_t  lmp_vers;
} ble_peer_version_ind_t;

typedef struct 
{
    uint8_t features[BLE_FEATS_LEN];
} ble_peer_features_ind_t;

typedef struct {
    uint16_t suggted_max_tx_octets;     
    uint16_t suggted_max_tx_time;       
} ble_sugg_dft_t;

typedef struct {
    uint16_t suppted_max_tx_octets;     
    uint16_t suppted_max_tx_time;       
    uint16_t suppted_max_rx_octets;     
    uint16_t suppted_max_rx_time;       
} ble_supp_dft_t;

typedef struct 
{
    int8_t min_tx_pwr;      
    int8_t max_tx_pwr;  
} ble_tx_pwr_t;


typedef struct 
{
    uint16_t con_intv_min;
    uint16_t con_intv_max;
    uint16_t slave_latency;
    uint16_t conn_timeout;
} ble_slv_pref_t;

typedef struct
{
    uint8_t  addr[BLE_BDADDR_LEN];
} ble_addr_t;

typedef struct
{
    uint8_t map[BLE_CHNL_MAP_LEN];
} ble_chnl_map_t;


typedef struct 
{
    uint8_t     nb[BLE_RAND_NB_LEN];
} ble_rnd_nb_t;

typedef struct
{
    uint8_t x[BLE_P256_KEY_LEN];
    uint8_t y[BLE_P256_KEY_LEN];
} ble_pub_key_t;

typedef struct 
{
    ble_addr_t addr;
    uint8_t addr_type;
} ble_bdaddr_t;

typedef struct 
{
    ble_bdaddr_t addr;
    uint8_t priv_mode;
    uint8_t peer_irk[BLE_KEY_LEN];
    uint8_t local_irk[BLE_KEY_LEN];
} ble_ral_dev_info_t;

typedef struct 
{
    ble_bdaddr_t addr;  
    uint8_t adv_sid;    
} ble_pal_dev_info_t;

typedef struct 
{
    uint8_t key[BLE_KEY_LEN];
} ble_sec_key_t;

typedef struct 
{
    ble_sec_key_t ltk;
    uint16_t ediv;
    ble_rnd_nb_t randnb;
    uint8_t key_size;
} ble_ltk_t;

typedef struct 
{
    ble_sec_key_t irk;
    ble_bdaddr_t addr;
} ble_irk_t;

typedef struct 
{
    uint8_t info;

    bool ltk_present;
} ble_bond_auth_t;

typedef struct 
{
    uint8_t conf[BLE_KEY_LEN];  
    uint8_t rand[BLE_KEY_LEN];  
} ble_oob_t;

typedef struct 
{
    uint8_t value[4];
} ble_nc_t;

typedef struct 
{
    uint8_t iocap;  
    uint8_t oob;        
    uint8_t auth;   
    uint8_t key_size;   
    uint8_t ikey_dist;  
    uint8_t rkey_dist;  
    uint8_t sec_req;    
} ble_pairing_t;

typedef struct 
{
    uint8_t tx_phy;     
    uint8_t rx_phy;     
} ble_phy_ind_t;


typedef struct {
    int test_mode;                  
    uint8_t channel;                
    uint8_t tx_data_length;     
    uint8_t tx_pkt_payload;     
    uint8_t phy;                        
    uint8_t modulation_idx;     
} ble_test_mode_t;

typedef struct 
{
    uint8_t role;

    uint16_t renew_dur;

    ble_addr_t addr;

    ble_sec_key_t irk;

    uint8_t privacy_cfg;


    uint8_t pairing_mode;


    uint16_t gap_start_hdl;

    uint16_t gatt_start_hdl;

    uint8_t att_devname_write_perm;     
    uint8_t att_apperance_write_perm;   
    uint8_t att_slv_pref_conn_param_present;        
    uint8_t svc_change_feat_present;    

    uint16_t sugg_max_tx_octets;
    uint16_t sugg_max_tx_time;

    uint16_t max_mtu;
    uint16_t max_mps;
    uint8_t  max_nb_lecb;

    uint8_t tx_pref_phy;
    uint8_t rx_pref_phy;

} ble_set_dev_config_t;

typedef union {
    ble_dev_verison_t version;
    ble_bdaddr_t bd_addr;
    int8_t adv_tx_pwr;
    ble_sugg_dft_t sugg_dft;
    ble_supp_dft_t supp_dft;    
    uint8_t list_size;
    uint8_t nb_adv_sets;
    uint16_t max_adv_len;       
    ble_tx_pwr_t tx_pwr;
} ble_local_dev_info_t;

typedef struct 
{
    ble_addr_t addr;    
    uint8_t nb_key;     
    ble_sec_key_t irk[];    
} ble_rnd_addr_resolve_t;

typedef struct 
{
    ble_addr_t addr;    
    ble_sec_key_t irk;                                      
} ble_rnd_addr_solved_t;

typedef struct 
{
    uint8_t key[BLE_KEY_LEN];           
    uint8_t plain_text[BLE_KEY_LEN];    
} ble_aes_enc_t;

typedef struct 
{
    uint16_t lepsm;     
    uint8_t sec_lvl;        
    bool full_key_size;             
} ble_lepsm_param_t;

typedef struct 
{
    int opcode;
    ble_bdaddr_t identity_addr;
} ble_get_ral_addr_t;

typedef struct 
{
    uint8_t size;       
    ble_bdaddr_t wl_info[]; 
} ble_wl_param_t;

typedef struct 
{
    uint8_t size;       
    ble_ral_dev_info_t ral_info[];  
} ble_ral_param_t;

typedef struct 
{
    uint8_t size;       
    ble_pal_dev_info_t pal_info[];      
} ble_pal_param_t;

struct adv_prim_cfg
{
    uint32_t adv_intv_min;      
    uint32_t adv_intv_max;      
    uint8_t chnl_map;               
    uint8_t phy;                        
};

struct adv_second_cfg
{
    uint8_t max_skip;   
    uint8_t phy;            
    uint8_t adv_sid;        
};

struct adv_period_cfg
{
    uint16_t adv_intv_min;      
    uint16_t adv_intv_max;      
};

typedef struct 
{
    uint8_t type;                                           
    uint8_t disc_mode;                              
    uint16_t prop;
    int8_t max_tx_pwr;                                  
    uint8_t filter_pol;                                 
    ble_bdaddr_t peer_addr;                             
    struct adv_prim_cfg prim_cfg;               
    struct adv_second_cfg second_cfg;       
    struct adv_period_cfg period_cfg;           
} adv_create_param_t;

typedef struct 
{
    int option;                             
    uint8_t own_addr_type;
    adv_create_param_t adv_param;               
} ble_actv_create_t;

typedef struct {
    uint16_t duration;      
    uint8_t max_adv_evt;    
}  ble_adv_start_t;

struct scan_wd_op_param
{
    uint16_t scan_intv; 
    uint16_t scan_wd;       
};

typedef struct
{
    uint8_t type;   
    uint8_t prop;   
    uint8_t dup_filt_pol;   
    struct scan_wd_op_param scan_param_1m;  
    struct scan_wd_op_param scan_param_coded;   
    uint16_t duration;
    uint16_t period;
    uint8_t chn;
}  ble_scan_start_t;

struct conn_param
{
    uint16_t conn_intv_min; 
    uint16_t conn_intv_max; 
    uint16_t conn_latency;  
    uint16_t supervision_to;
};

typedef struct 
{
    uint8_t type;   
    uint8_t prop;   
    uint16_t conn_tmo;  
    struct scan_wd_op_param scan_param_1m;  
    struct scan_wd_op_param scan_param_coded;   
    struct conn_param conn_param_1m;    
    struct conn_param conn_param_2m;    
    struct conn_param conn_param_coded; 
    ble_bdaddr_t peer_addr; 
} ble_init_start_t;

struct period_adv_addr_cfg
{
    ble_bdaddr_t addr;      
    uint8_t adv_sid;    
};

typedef struct 
{
    uint8_t type;   
    uint16_t skip;  
    uint16_t sync_tmo;  
    struct period_adv_addr_cfg adv_addr;    
} ble_per_sync_start_t;

typedef struct {
    int option;                             
    union {
        ble_adv_start_t adv_param;  
        ble_scan_start_t scan_param;    
        ble_init_start_t init_param;
        ble_per_sync_start_t per_param;
    } u;
} ble_actv_start_t;

typedef struct 
{
    ble_sec_key_t lcsrk;    
    uint32_t lsign_counter; 
    ble_sec_key_t rcsrk;    
    uint32_t rsign_counter; 
    uint8_t auth;   
    uint8_t svc_changed_ind_enable; 
    bool ltk_present;   
} ble_conn_cfm_t;

typedef union {
    ble_dev_name_t name;    
    uint16_t apperance;
    ble_slv_pref_t slv_pref_params;     
    uint8_t ctl_addr_resol;
    ble_peer_version_ind_t version;
    ble_peer_features_ind_t features;
    int8_t rssi;
    ble_chnl_map_t ch_map;
    uint16_t ping_timeout;      
    ble_phy_ind_t phy;
    uint8_t chan_sel_algo;
} ble_conn_peer_info_t;

typedef struct 
{
    uint16_t intv_min;      
    uint16_t intv_max;  
    uint16_t latency;       
    uint16_t time_out;  
} ble_conn_param_update_t;

typedef struct 
{
    uint8_t found;  
    ble_sec_key_t ltk;  
    uint8_t key_size;   
} ble_conn_encrypt_cfm_t;


typedef struct
{
    uint8_t request;

    uint8_t accept;

    union {
        ble_pairing_t pairing_feat;     
        ble_ltk_t ltk;                                  
        ble_sec_key_t csrk;                     
        ble_sec_key_t tk;                           
        ble_irk_t irk;                                  
        ble_oob_t oob;                              
    } u;
} ble_bond_cfm_t;

typedef struct 
{
    uint8_t tx_phy;     
    uint8_t rx_phy;     
    uint8_t phy_opt;    
} ble_conn_pref_phy_t;

typedef struct 
{
    uint16_t tx_octets;     
    uint16_t tx_time;           
} ble_pref_le_pkt_size_t;

typedef struct 
{
    uint16_t max_tx_octets;
    uint16_t max_tx_time;
    uint16_t max_rx_octets;
    uint16_t max_rx_time;
} ble_le_pkt_size_t;

typedef struct {
    uint8_t  sec_lvl;
    uint16_t start_hdl;
    uint32_t param[];
} ble_add_prf_t;


/*@TRACE*/
typedef struct {
    uint8_t req;
    union {
            //@trc_union parent.req == GAPC_DEV_NAME
            ble_dev_name_t name;
            //@trc_union parent.req == GAPC_DEV_APPEARANCE
            uint16_t appearance;
            //@trc_union parent.req == GAPC_DEV_SLV_PREF_PARAMS
             ble_slv_pref_t slv_pref_params;
            //@trc_union parent.req == GAPC_DEV_CTL_ADDR_RESOL
            uint8_t ctl_addr_resol;                 
        } u;
} ble_get_dev_info_cfm_t;


typedef struct{
    uint8_t req;

    uint8_t status;
} ble_set_dev_info_cfm_t;


/*
 ****************************************************************************************
 * functions
 ****************************************************************************************
 */

int in_ble_reset(void *hdl, comp_cb callback);


int in_ble_get_chn_assess(void *hdl, int chn, int8_t *level, uint32_t * timestamp);

int in_ble_test(void *hdl, ble_test_mode_t *p_test, uint16_t *nb_rx_packet, comp_cb callback);

int in_ble_set_dev_config(void *hdl, ble_set_dev_config_t *p_cfg, comp_cb callback);

int in_ble_get_dev_info(void *hdl, int cmd, ble_local_dev_info_t *p_info, comp_cb callback);

int in_ble_set_chn_map(void *hdl, ble_chnl_map_t *p_chn_map, comp_cb callback);

int in_ble_resolve_addr(void *hdl, ble_rnd_addr_resolve_t *p_rnd_addr, ble_rnd_addr_solved_t *p_addr, comp_cb callback);

int in_ble_gen_random_addr(void *hdl, int rnd_addr_type, ble_bdaddr_t *p_rnd_addr, comp_cb callback);

int in_ble_aes_enc(void *hdl, ble_aes_enc_t *p_enc, uint8_t *p_enc_res, comp_cb callback);

int in_ble_get_pub_key(void *hdl, int renew, ble_pub_key_t* p_pub_key, comp_cb callback);



int in_ble_gen_random_nb(void *hdl, ble_rnd_nb_t *p_rnd_nb, comp_cb callback);

int in_ble_set_irk(void *hdl, ble_sec_key_t *p_irk, comp_cb callback);

int in_ble_register_lepsm(void *hdl, ble_lepsm_param_t *p_psm, comp_cb callback);

int in_ble_unregister_lepsm(void *hdl, uint32_t psm, comp_cb callback);

int in_ble_get_ral_addr(void *hdl, ble_get_ral_addr_t *p_ral_addr, ble_bdaddr_t *p_addr, comp_cb callback);

int in_ble_set_white_list(void *hdl, ble_wl_param_t *p_wlist, comp_cb callback);

int in_ble_set_ral_list(void *hdl, ble_ral_param_t *p_ral, comp_cb callback);

int in_ble_set_pal_list(void *hdl, ble_pal_param_t *p_pal, comp_cb callback);

int in_ble_actv_create(void *hdl, ble_actv_create_t *p_act, int *p_actv_idx, comp_cb callback);

int in_ble_actv_start(void *hdl, int actv_idx, ble_actv_start_t *p_start, comp_cb callback);

int in_ble_actv_data(void *hdl, int actv_idx, int option, uint8_t *data, uint32_t data_len, comp_cb callback);

int in_ble_actv_stop(void *hdl, int actv_idx, comp_cb callback);

int in_ble_actv_del(void *hdl, int actv_idx, comp_cb callback);

int in_ble_conn_cfm(void *hdl, int conidx, ble_conn_cfm_t *p_cfm);

int in_ble_conn_disconnect(void *hdl, int conidx, uint32_t reason, comp_cb callback);

int in_ble_conn_get_peer_info(void *hdl, int conidx, int option, ble_conn_peer_info_t *p_peer_info, comp_cb callback);

int in_ble_conn_param_update(void *hdl, int conidx, ble_conn_param_update_t *p_upd, comp_cb callback);

int in_ble_conn_param_update_cfm(void *hdl, int conidx, bool accept);

int in_ble_conn_req_encrypt(void *hdl, int conidx, ble_ltk_t *p_ltk, comp_cb callback);

int in_ble_conn_req_encrypt_cfm(void *hdl, int conidx, ble_conn_encrypt_cfm_t *p_cfm);

int in_ble_conn_req_security(void *hdl, int conidx, int auth, comp_cb callback);

int in_ble_conn_set_ping_tmo(void *hdl, int conidx, uint32_t timeout, comp_cb callback);

int in_ble_conn_set_pkt_size(void *hdl, uint8_t conidx, ble_pref_le_pkt_size_t *p_pref_pkt_size, ble_le_pkt_size_t *p_pkt_size, comp_cb callback);

int in_ble_conn_bond(void *hdl, int conidx, ble_pairing_t *p_bond, comp_cb callback);

int in_ble_conn_bond_cfm(void *hdl, int conidx, ble_bond_cfm_t *p_cfm);

int in_ble_conn_set_pref_phy(void *hdl, int conidx, ble_conn_pref_phy_t *p_phy, ble_phy_ind_t *p_phy_ind, comp_cb callback);

int in_ble_conn_keypress_notify(void *hdl, int conidx, int key_state, comp_cb callback);

int in_ble_conn_get_dev_info_cfm(void *hdl, int conidx,  ble_get_dev_info_cfm_t *p_cfm);

int in_ble_conn_set_dev_info_cfm(void *hdl, int conidx, ble_set_dev_info_cfm_t *p_cfm);



#endif  // IN_BLE_GAP_H