path: root/platform/atm2/ATM22xx-x1x/lib/ble_gap/ble_gap.h

/**
 *******************************************************************************
 *
 * @file ble_gap.h
 *
 * @brief Header file - BLE GAP API.
 *
 * Copyright (C) Atmosic 2020-2023
 *
 *
 *******************************************************************************
 */
#pragma once

/**
 *******************************************************************************
 * @defgroup ATM_BTFM_BLE_GAP GAP API
 * @ingroup ATM_BTFM_API
 * @brief ATM bluetooth framework GAP API
 *
 * This module contains the necessary API to deal with the GAP messages.
 *
 * @{
 *******************************************************************************
 */


/*
 * INCLUDE FILES
 *******************************************************************************
 */

#include "co_bt.h"     // Common BT Definitions
#include "gap.h"       // GAP Definition
#include "gapm.h"
#include "gapc.h"
#include "ble_common.h"
#include "ble_err.h"

#ifdef __cplusplus
extern "C" {
#endif

/// Key length
#define BLE_GAP_KEY_LEN 16
/// Random number number
#define BLE_GAP_RAND_NB_LEN 8
/// Maximum test TX power level
#define BLE_GAP_MAX_TEST_TX_PWR_LVL 0x7F
/// Minimum switching pattern length
#define BLE_GAP_MIN_SWITCHING_PATTERN_LEN 2
/// Maximum switching pattern length
#define BLE_GAP_MAX_SWITCHING_PATTERN_LEN 0x4B
/// LE Feature Flags Length
#define BLE_GAP_LE_FEATS_LEN 8
/// LE Channel map length
#define BLE_GAP_LE_CHNL_MAP_LEN 5
/// Scanning window (in 625us slot)
#define BLE_SCAN_WINDOW_DFT 0x0010
/// Scanning interval (in 625us slot)
#define BLE_SCAN_INTERVAL_DFT 0x0010
/// Database hash length
#define BLE_GAP_DATABASE_HASH_LEN 16

/*
 * TYPEDEFINE
 *******************************************************************************
 */

/// Random Address type
typedef enum {
    /// Static random address
    BLE_GAP_STATIC_ADDR = 0xc0,
    /// Private non-resolvable address
    BLE_GAP_NON_RSLV_ADDR = 0x00,
    /// Private resolvable address
    BLE_GAP_RSLV_ADDR = 0x40,
} ble_gapm_rand_addr_type_t;

/// BLE ADV data type
typedef enum {
    /// Advertising data
    BLE_GAPM_ADV_DATA,
    /// Scan response data
    BLE_GAPM_SCAN_RSP_DATA,
    /// Periodic advertising data
    BLE_GAPM_PERIOD_ADV_DATA
} ble_gapm_data_type_t;

typedef enum {
    /// Extended advertising report
    BLE_GAP_REPORT_TYPE_ADV_EXT,
    /// Legacy advertising report
    BLE_GAP_REPORT_TYPE_ADV_LEG,
    /// Extended scan response report
    BLE_GAP_REPORT_TYPE_SCAN_RSP_EXT,
    /// Legacy scan response report
    BLE_GAP_REPORT_TYPE_SCAN_RSP_LEG,
    /// Periodic advertising report
    BLE_GAP_REPORT_TYPE_PER_ADV,
} ble_gap_adv_report_type_t;

typedef enum {
    /// Report Type (see ble_gap_adv_report_type_t)
    BLE_GAP_REPORT_INFO_REPORT_TYPE_MASK = 0x07,
    /// Report is complete
    BLE_GAP_REPORT_INFO_COMPLETE_BIT = (1 << 3),
    /// Connectable advertising
    BLE_GAP_REPORT_INFO_CONN_ADV_BIT = (1 << 4),
    /// Scannable advertising
    BLE_GAP_REPORT_INFO_SCAN_ADV_BIT = (1 << 5),
    /// Directed advertising
    BLE_GAP_REPORT_INFO_DIR_ADV_BIT = (1 << 6),
} ble_gap_adv_report_info_t;

/// Packet payload type for test mode
typedef enum {
    /// PRBS9 sequence "11111111100000111101..." (in transmission order)
    BLE_GAP_PKT_PLD_PRBS9,
    /// Repeated "11110000" (in transmission order)
    BLE_GAP_PKT_PLD_REPEATED_11110000,
    /// Repeated "10101010" (in transmission order)
    BLE_GAP_PKT_PLD_REPEATED_10101010,
    /// PRBS15 sequence
    BLE_GAP_PKT_PLD_PRBS15,
    /// Repeated "11111111" (in transmission order) sequence
    BLE_GAP_PKT_PLD_REPEATED_11111111,
    /// Repeated "00000000" (in transmission order) sequence
    BLE_GAP_PKT_PLD_REPEATED_00000000,
    /// Repeated "00001111" (in transmission order) sequence
    BLE_GAP_PKT_PLD_REPEATED_00001111,
    /// Repeated "01010101" (in transmission order) sequence
    BLE_GAP_PKT_PLD_REPEATED_01010101,
} ble_gap_pkt_pld_type_t;

/// Enumeration of TX PHY values
typedef enum {
    /// LE 1M PHY
    BLE_GAP_TX_PHY_1MBPS = 1,
    /// LE 2M PHY
    BLE_GAP_TX_PHY_2MBPS = 2,
    /// LE Coded PHY with S=8 data coding
    BLE_GAP_TX_PHY_125KBPS = 3,
    /// LE Coded PHY with S=2 data coding
    BLE_GAP_TX_PHY_500KBPS = 4,
} ble_gap_tx_phy_val_t;

/// Enumeration of RX PHY values
typedef enum {
    /// LE 1M PHY
    BLE_GAP_RX_PHY_1MBPS = 1,
    /// LE 2M PHY
    BLE_GAP_RX_PHY_2MBPS = 2,
    /// LE Coded PHY
    BLE_GAP_RX_PHY_CODED = 3,
} ble_gap_rx_phy_val_t;

/// Enumeration of PHY values
typedef enum {
    /// LE 1M PHY
    BLE_GAP_PHY_1MBPS = 1,
    /// LE 2M PHY
    BLE_GAP_PHY_2MBPS = 2,
    /// LE Coded PHY
    BLE_GAP_PHY_CODED = 3,
} ble_gap_phy_val_t;

/// Constant tone extension type
typedef enum {
    /// AoA constant tone extension
    BLE_GAP_CTE_AOA,
    /// AoD constant tone extension with 1 us slots
    BLE_GAP_CTE_AOD_1US,
    /// AoD constant tone extension with 2 us slots
    BLE_GAP_CTE_AOD_2US,
} ble_gap_cte_type_t;

/// LE transmitter test parameters
typedef struct {
    /// TX channel (range: 0x00 to 0x27)
    uint8_t ch;
    /// Length in bytes of payload data in each packet
    uint8_t test_data_len;
    /// Packet payload type
    ble_gap_pkt_pld_type_t pkt_pld_type;
    /// PHY
    ble_gap_tx_phy_val_t phy;
    /// CTE length
    uint8_t cte_len;
    /// CTE type
    ble_gap_cte_type_t cte_type;
    /// Transmit power level in dBm (0x7E: minimum | 0x7F: maximum | range: -127
    /// to +20)
    int8_t tx_pwr_lvl;
    /// The number of antenna IDs in the pattern (range: 0x02 to 0x4B)
    uint8_t switching_pattern_len;
    /// Antenna IDs
    uint8_t antenna_id[__ARRAY_EMPTY];
} ble_gap_test_tx_param_t;

/// Modulation index
typedef enum {
    /// Assume transmitter will have a standard modulation index
    BLE_GAP_MODULATION_STANDARD,
    /// Assume transmitter will have a stable modulation index
    BLE_GAP_MODULATION_STABLE,
} ble_gap_mod_idx_t;

/// Slot durations
typedef enum {
    /// Switching and sampling slots are 1 μs each
    BLE_GAP_SLOT_DUR_1US = 1,
    /// Switching and sampling slots are 2 μs each
    BLE_GAP_SLOT_DUR_2US,
} ble_gap_slot_dur_t;

/// LE receiver test parameters
typedef struct {
    /// RX channel (range: 0x00 to 0x27)
    uint8_t ch;
    /// PHY
    ble_gap_rx_phy_val_t phy;
    /// Modulation index
    ble_gap_mod_idx_t mod_idx;
    /// Expected CTE length
    uint8_t exp_cte_len;
    /// Expected CTE type
    ble_gap_cte_type_t exp_cte_type;
    /// Slot durations
    ble_gap_slot_dur_t slot_dur;
    /// The number of antenna IDs in the pattern (range: 0x02 to 0x4B)
    uint8_t switching_pattern_len;
    /// Antenna IDs
    uint8_t antenna_id[__ARRAY_EMPTY];
} ble_gap_test_rx_param_t;

/// BLE ADV channel selection
typedef enum {
    /// Channel 37
    ADV_37_CHNL = (1 << 0),
    /// Channel 38
    ADV_38_CHNL = (1 << 1),
    /// Channel 39
    ADV_39_CHNL = (1 << 2),
    /// Channel 37, 38 and 39
    ADV_ALL_CHNLS = ADV_37_CHNL | ADV_38_CHNL | ADV_39_CHNL
} ble_adv_chnl_t;

/// Advertising properties bit field bit value
typedef enum {
    /// Indicate that advertising is connectable, reception of
    /// CONNECT_IND or AUX_CONNECT_REQ PDUs is accepted. Not applicable
    /// for periodic advertising.
    ADV_PROP_CONNECTABLE_BIT = (1 << 0),
    /// Indicate that advertising is scannable, reception of SCAN_REQ or
    /// AUX_SCAN_REQ PDUs is accepted
    ADV_PROP_SCANNABLE_BIT = (1 << 1),
    /// Indicate that advertising targets a specific device. Only apply
    /// in
    /// following cases:
    ///   - Legacy advertising: if connectable
    ///   - Extended advertising: connectable or (non connectable and
    /// non discoverable)
    ADV_PROP_DIRECTED_BIT = (1 << 2),
    /// Indicate that High Duty Cycle has to be used for advertising on
    /// primary channel Apply only if created advertising is not an
    /// extended advertising
    ADV_PROP_HDC_BIT = (1 << 3),
    /// Reserved for bit 4
    ADV_PROP_RESERVED_4_BIT = (1 << 4),
    /// Enable anonymous mode. Device address won't appear in send PDUs
    /// Valid only if created advertising is an extended advertising
    ADV_PROP_ANONYMOUS_BIT = (1 << 5),
    /// Include TX Power in the extended header of the advertising PDU.
    /// Valid only if created advertising is not a legacy advertising
    ADV_PROP_TX_PWR_BIT = (1 << 6),
    /// Include TX Power in the periodic advertising PDU.
    /// Valid only if created advertising is a periodic advertising
    ADV_PROP_PER_TX_PWR_BIT = (1 << 7),
    /// Indicate if application must be informed about received scan
    /// requests PDUs
    ADV_PROP_SCAN_REQ_NTF_EN_BIT = (1 << 8),
} ble_adv_prop_t;

/// Leggacy advertising properties. Used when type is ADV_TYPE_LEGACY
enum adv_crt_leg_prop {
    /// Non connectable non scannable advertising
    ADV_LEGACY_NON_CONN_NON_SCAN_MASK,
    /// Broadcast non scannable advertising - Discovery mode must be
    /// Non Discoverable
    ADV_LEGACY_BROADCAST_NON_SCAN_MASK =
	ADV_LEGACY_NON_CONN_NON_SCAN_MASK,
    /// Non connectable scannable advertising
    ADV_LEGACY_NON_CONN_SCAN_MASK = ADV_PROP_SCANNABLE_BIT,
    /// Broadcast non scannable advertising - Discovery mode must be Non
    /// Discoverable
    ADV_LEGACY_BROADCAST_SCAN_MASK = ADV_LEGACY_NON_CONN_SCAN_MASK,
    /// Undirected connectable advertising
    ADV_LEGACY_UNDIR_CONN_MASK = ADV_PROP_CONNECTABLE_BIT |
	ADV_PROP_SCANNABLE_BIT,
    /// Directed connectable advertising
    ADV_LEGACY_DIR_CONN_MASK = ADV_PROP_DIRECTED_BIT |
	ADV_PROP_CONNECTABLE_BIT,
    /// Directed connectable with Low Duty Cycle
    ADV_LEGACY_DIR_CONN_LDC_MASK = ADV_LEGACY_DIR_CONN_MASK,
    /// Directed connectable with High Duty Cycle
    ADV_LEGACY_DIR_CONN_HDC_MASK = ADV_LEGACY_DIR_CONN_MASK |
	ADV_PROP_HDC_BIT,
};

/// Leggacy advertising properties. Used when type is ADV_TYPE_EXTENDED
enum adv_crt_ext_prop {
    /// Non connectable non scannable extended advertising
    ADV_EXT_NON_CONN_NON_SCAN_MASK,
    /// Non connectable scannable extended advertising
    ADV_EXT_NON_CONN_SCAN_MASK = ADV_PROP_SCANNABLE_BIT,
    /// Non connectable scannable directed extended advertising
    ADV_EXT_NON_CONN_SCAN_DIR_MASK = ADV_PROP_SCANNABLE_BIT |
	ADV_PROP_DIRECTED_BIT,
    /// Non connectable anonymous directed extended advertising
    ADV_EXT_ANONYM_DIR_MASK = ADV_PROP_ANONYMOUS_BIT |
	ADV_PROP_DIRECTED_BIT,
    /// Undirected connectable extended advertising
    ADV_EXT_UNDIR_CONN_MASK = ADV_PROP_CONNECTABLE_BIT,
    /// Directed connectable extended advertising
    ADV_EXT_DIR_CONN_MASK = ADV_PROP_CONNECTABLE_BIT |
	ADV_PROP_DIRECTED_BIT,
};

/// Periodic advertising properties. Used when type is ADV_TYPE_PERIODIC
enum adv_crt_per_prop {
    /// Undirected periodic advertising
    ADV_PER_UNDIR_MASK,
    /// Directed periodic advertising
    ADV_PER_DIR_MASK = ADV_PROP_DIRECTED_BIT,
};

/// Advertising parameters for advertising creation
typedef struct {
    /// Advertising type
    enum adv_crt_type {
	/// Legacy advertising
	ADV_TYPE_LEGACY,
	/// Extended advertising
	ADV_TYPE_EXTENDED,
	/// Periodic advertising
	ADV_TYPE_PERIODIC,
    } type;

    /// Advertising discovery mode
    enum adv_crt_mode {
	/// Mode in non-discov rable
	ADV_MODE_NON_DISC,
	/// Mode in general discoverable
	ADV_MODE_GEN_DISC,
	/// Mode in limited discoverable
	ADV_MODE_LIM_DISC,
	/// Broadcast mode without presence of AD_TYPE_FLAG in advertising data
	ADV_MODE_BEACON,
	/// Number of mode
	ADV_MODE_MAX,
    } disc_mode;

    /// Advertising property
    /// This may come from OR operation of values of ble_adv_prop_t
    /// with one of value from @see enum adv_crt_leg_prop,
    /// @see enum adv_crt_ext_prop or @see enum adv_crt_per_prop.
    uint16_t prop;

    /// Maximum power level at which the advertising packets have to be
    /// transmitted (between -127 and 126 dBm)
    int8_t max_tx_pwr;
    /// Advertising filter policy
    enum adv_crt_filter_policy {
	/// Allow both scan and connection requests from anyone
	FILTER_SCAN_ANY_CON_ANY,
	/// Allow both scan req from White List devices only and connection req
	/// from anyone
	FILTER_SCAN_WLST_CON_ANY,
	/// Allow both scan req from anyone and connection req from White List
	/// devices only
	FILTER_SCAN_ANY_CON_WLST,
	/// Allow scan and connection requests from White List devices only
	FILTER_SCAN_WLST_CON_WLST,
    } filter_pol;
    /// Peer address configuration (only used in case of directed advertising)
    ble_gap_bdaddr_t peer_addr;
    /// Configuration for advertising on primary channel
    struct primary_config {
	/// Minimum advertising interval (in unit of 625us). Must be greater
	/// than 20ms
	uint32_t adv_intv_min;
	/// Maximum advertising interval (in unit of 625us). Must be greater
	/// than 20ms
	uint32_t adv_intv_max;
	/// Bit field indicating the channel mapping. Bit number 0/1/2 is
	/// channel number 37/38/39.
	ble_adv_chnl_t chnl_map;
	/// Note that LE 2M PHY is not allowed and that legacy advertising only
	/// support LE 1M PHY
	ble_gap_phy_val_t phy;
    } prim_cfg;
    /// Configuration for secondary advertising (valid only if advertising type
    /// is ADV_TYPE_EXTENDED or ADV_TYPE_PERIODIC)
    struct second_config {
	/// Maximum number of advertising events the controller can skip before
	/// sending the
	/// AUX_ADV_IND packets. 0 means that AUX_ADV_IND PDUs shall be sent
	/// prior each
	/// advertising events
	uint8_t max_skip;
	/// Indicate on which PHY secondary advertising has to be performed
	ble_gap_phy_val_t phy;
	/// Advertising SID
	uint8_t adv_sid;
    } second_cfg;
    /// Configuration for periodic advertising (valid only if advertising type
    /// is ADV_TYPE_PERIODIC)
    struct periodic_config {
	/// Minimum advertising interval (in unit of 1.25ms). Must be greater
	/// than 20ms
	uint16_t adv_intv_min;
	/// Maximum advertising interval (in unit of 1.25ms). Must be greater
	/// than 20ms
	uint16_t adv_intv_max;
    } period_cfg;
} ble_gapm_adv_create_param_t;

/// Generic key structure
typedef struct {
    /// Key value MSB -> LSB
    uint8_t key[BLE_GAP_KEY_LEN];
} ble_gap_key_t;

typedef struct {
    /// Identity Resolving Key
    ble_gap_key_t irk;
    /// Device BD Identity Address
    ble_gap_bdaddr_t addr;
} ble_gap_irk_t;

/// Bit field use to select the preferred TX or RX LE PHY. 0 means no
/// preferences.
typedef enum {
    /// No preferred PHY.
    BLE_GAP_PHY_ANY = 0x00,
    /// LE 1M PHY preferred for an active link.
    BLE_GAP_PHY_LE_1MBPS = (1 << 0),
    /// LE 2M PHY preferred for an active link.
    BLE_GAP_PHY_LE_2MBPS = (1 << 1),
    /// LE Coded PHY preferred for an active link.
    BLE_GAP_PHY_LE_CODED = (1 << 2),
} ble_gap_phy_mode_t;

/// Specify what rate Host prefers to use in transmission on coded PHY. refer to
/// HCI: 7.8.49
typedef enum {
    /// No preferred coding when transmitting on the LE Coded PHY.
    BLE_GAP_PHY_OPT_NO_LE_CODED_TX_PREF,
    /// Prefers that S=2 coding be used when transmitting on the LE Coded PHY.
    BLE_GAP_PHY_OPT_S2_LE_CODED_TX_PREF,
    /// Prefers that S=8 coding be used when transmitting on the LE Coded PHY.
    BLE_GAP_PHY_OPT_S8_LE_CODED_TX_PREF,
} ble_gap_phy_opt_t;

typedef enum {
    /// No role set yet
    BLE_GAP_ROLE_NONE = 0x00,
    /// Observer role
    BLE_GAP_ROLE_OBSERVER = 0x01,
    /// Broadcaster role
    BLE_GAP_ROLE_BROADCASTER = 0x02,
    /// Master/Central role
    BLE_GAP_ROLE_CENTRAL = (0x04 | BLE_GAP_ROLE_OBSERVER),
    /// Peripheral/Slave role
    BLE_GAP_ROLE_PERIPHERAL = (0x08 | BLE_GAP_ROLE_BROADCASTER),
    /// Device has all role, both peripheral and central
    BLE_GAP_ROLE_ALL = (BLE_GAP_ROLE_CENTRAL | BLE_GAP_ROLE_PERIPHERAL),
} ble_gap_role_t;

/// Privacy configuration
typedef enum {
    /// Identity address type. Public address:0, Static private random
    /// address:1
    BLE_GAP_PRIV_CFG_PRIV_ADDR_BIT = (1 << 0),
    /// Reserved
    BLE_GAP_PRIV_CFG_RSVD = (1 << 1),
    /// Enable controller privacy
    BLE_GAP_PRIV_CFG_PRIV_EN_BIT = (1 << 2),
} ble_gap_priv_cfg_t;

/// Pairing Mode
typedef enum {
    /// No pairing authorized
    BLE_GAP_PAIRING_DISABLE = 0,
    /// Legacy pairing Authorized
    BLE_GAP_PAIRING_LEGACY = (1 << 0),
    /// Secure Connection pairing Authorized
    BLE_GAP_PAIRING_SEC_CON = (1 << 1),
} ble_gap_pairing_mode_t;

/// Device Attribute write permission requirement
typedef enum {
    /// Disable write access
    BLE_GAP_WRITE_DISABLE,
    /// Enable write access - no authentication required
    BLE_GAP_WRITE_NO_AUTH,
    /// Write access requires unauthenticated link
    BLE_GAP_WRITE_UNAUTH,
    /// Write access requires authenticated link
    BLE_GAP_WRITE_AUTH,
    /// Write access requires secure connected link
    BLE_GAP_WRITE_SEC_CON,
} ble_gap_write_att_perm_t;

/// Attribute database configuration
///    8    7     6    5    4    3    2    1    0
/// +-----+----+-----+----+----+----+----+----+----+
/// | MTU | SC | PCP |   APP_PERM   |   NAME_PERM  |
/// +-----+----+-----+----+----+----+----+----+----+
///   15   14   13   12    11     10    9
/// +----+----+----+----+------+------+----+
/// |        RFU        | RPAO | EATT | FE |
/// +----+----+----+----+------+------+----+
/// - Bit [0-2]  : Device Name write permission requirements for peer device.
///                (@see ble_gap_write_att_perm_t)
/// - Bit [3-5]  : Device Appearance write permission requirements for peer
///                device (@see ble_gap_write_att_perm_t)
/// - Bit [6]    : Peripheral Preferred Connection Parameters present.
/// - Bit [7]    : Service change feature present in GATT attribute database.
/// - Bit [8]    : Enable automatic MTU exchange at connection establishment.
/// - Bit [9]    : Enable automatic client feature enable setup at connection
///                establishment.
/// - Bit [10]   : Enable automatic establishment of Enhanced ATT bearers.
/// - Bit [11]   : Enable presence of Resolvable private address only.
/// - Bit [12-15]: Reserve for future use.
typedef enum {
    /// Device Name write permission requirements for peer device
    /// (@see ble_gap_write_att_perm_t)
    BLE_GAP_ATT_NAME_PERM_MASK = 0x0007,
    BLE_GAP_ATT_NAME_PERM_POS = 0,
    /// Device Appearance write permission requirements for peer device
    /// (@see ble_gap_write_att_perm_t)
    BLE_GAP_ATT_APPEARENCE_PERM_MASK = 0x0038,
    BLE_GAP_ATT_APPEARENCE_PERM_POS = 3,
    /// Peripheral Preferred Connection Parameters present in GAP attribute
    /// database.
    BLE_GAP_ATT_PERIPH_PREF_CON_PAR_EN_MASK  = 0x0040,
    BLE_GAP_ATT_PERIPH_PREF_CON_PAR_EN_POS  = 6,
    /// Service change feature present in GATT attribute database.
    BLE_GAP_ATT_SVC_CHG_EN_MASK = 0x0080,
    BLE_GAP_ATT_SVC_CHG_EN_POS = 7,
    /// Automatic MTU exchange at connection establishment.
    BLE_GAP_ATT_CLI_AUTO_MTU_EXCH_EN_MASK = 0x0100,
    BLE_GAP_ATT_CLI_AUTO_MTU_EXCH_EN_POS = 8,
    /// Automatic client feature enable
    BLE_GAP_ATT_CLI_AUTO_FEAT_EN_MASK = 0x0200,
    BLE_GAP_ATT_CLI_AUTO_FEAT_EN_POS = 9,
    /// Automatic establishment of Enhanced ATT bearers.
    BLE_GAP_ATT_CLI_AUTO_EATT_EN_MASK = 0x0400,
    BLE_GAP_ATT_CLI_AUTO_EATT_POS = 10,
    /// Presence of Resolvable private address only.
    BLE_GAP_ATT_RSLV_PRIV_ADDR_ONLY_MASK = 0x0800,
    BLE_GAP_ATT_RSLV_PRIV_ADDR_ONLY_POS = 11,
} ble_gap_att_cfg_flag_t;

typedef struct {
    /// Device Role: Central, Peripheral, Observer, Broadcaster or All roles.
    ble_gap_role_t role;

    /// Privacy Config
    /// Duration before regenerate device address when privacy is enabled.
    /// unit:sec
    uint16_t renew_dur;
    /// Provided own static private random address
    ble_bdaddr_t addr;
    /// Device IRK used for resolvable random BD address generation (LSB first)
    ble_gap_key_t irk;
    /// Privacy configuration bit field
    ble_gap_priv_cfg_t privacy_cfg;

    /// Security Config
    /// Pairing mode authorized
    ble_gap_pairing_mode_t pairing_mode;

    /// ATT Database Config
    /// GAP service start handle
    uint16_t gap_start_hdl;
    /// GATT service start handle
    uint16_t gatt_start_hdl;
    /// Attribute database configuration
    ble_gap_att_cfg_flag_t att_cfg;

    /// LE Data Length Extension
    /// Suggested value for the Controller's maximum transmitted number of
    /// payload octets to be used
    uint16_t sugg_max_tx_octets;
    /// Suggested value for the Controller's maximum packet transmission time to
    /// be used (unit: micro sec)
    uint16_t sugg_max_tx_time;

    /// L2CAP Configuration
    /// Maximal MTU size
    uint16_t max_mtu;
    /// Maximal MPS Packet size
    uint16_t max_mps;
    /// Maximum number of LE Credit based connection that can be established
    uint8_t max_nb_lecb;

    /// LE PHY Management
    /// Preferred LE PHY for data transmission
    ble_gap_phy_mode_t tx_pref_phy;
    /// Preferred LE PHY for data reception
    ble_gap_phy_mode_t rx_pref_phy;

    /// Other settings
    /// RF TX Path Compensation value (from -128dB to 128dB, unit is 0.1dB)
    uint16_t tx_path_comp;
    /// RF RX Path Compensation value (from -128dB to 128dB, unit is 0.1dB)
    uint16_t rx_path_comp;
} ble_gap_set_dev_config_t;

/// BLE peer info type
typedef enum {
    /// Retrieve name of peer device.
    BLE_GAP_GET_PEER_NAME,
    /// Retrieve peer device version info.
    BLE_GAP_GET_PEER_VERSION,
    /// Retrieve peer device features.
    BLE_GAP_GET_PEER_FEATURES,
    /// Retrieve connection RSSI.
    BLE_GAP_GET_CON_RSSI,
    /// Retrieve connection channel map.
    BLE_GAP_GET_CON_CHANNEL_MAP,
    /// Get peer device appearance.
    BLE_GAP_GET_PEER_APPEARANCE,
    /// Get peer device peripheral preferred parameters.
    BLE_GAP_GET_PEER_PERIPH_PREF_PARAMS,
    /// Get timer timeout value.
    BLE_GAP_GET_LE_PING_TO,
    /// Central address resolution supported.
    BLE_GAP_GET_ADDR_RESOL_SUPP,
    /// Retrieve PHY configuration of active link.
    BLE_GAP_GET_PHY,
    /// Retrieve channel selection algorithm.
    BLE_GAP_GET_CHAN_SEL_ALGO,
} ble_gap_link_info_type_t;

/// Peer irk structure
typedef struct {
    /// irk information
    ble_gap_irk_t irk;
    /// Bonding Index
    int idx;
} ble_gap_irk_idx_t;

/// Resolving address command complete event data structure
typedef struct {
    /// Index of irk
    uint8_t index;
    /// Number of irk
    uint8_t nb;
    /// Irk
    ble_gap_irk_idx_t irk[__ARRAY_EMPTY];
} resl_addr_t;

/// Connection parameter
typedef struct {
    /// Connection interval minimum
    uint16_t intv_min;
    /// Connection interval maximum
    uint16_t intv_max;
    /// Latency
    uint16_t latency;
    /// Supervision timeout
    uint16_t time_out;
} ble_gap_conn_param_t;

typedef struct {
    /// GAP requested operation
    uint8_t operation;
    /// Status of the request
    uint8_t status;
} gapm_cmp_evt_t;

/// The list of names for registered gap event function.
typedef enum {
    /// Handler in atm_gap.
    GAP_EVT_NAME_ATM_GAP,
    /// Handler in ble_gap_sec.
    GAP_EVT_NAME_BLE_GAP_SEC,
    /// Handler in test.
    GAP_EVT_NAME_TEST,
    /// Max number of this enumerations.
    GAP_EVT_NAME_MAX,
} ble_gap_evt_reg_name_t;

typedef struct {
    /// 8-byte array for random number
    uint8_t nb[BLE_GAP_RAND_NB_LEN];
} ble_rand_nb_t;

typedef struct ble_gap_ext_adv_report_ind {
    /// Bit field info
    ble_gap_adv_report_info_t info;
    /// Transmitter device address
    ble_gap_bdaddr_t trans_addr;
    /// Target device address
    /// Valid only for directed advertising report
    ble_gap_bdaddr_t target_addr;
    /// TX power (in dBm)
    int8_t tx_pwr;
    /// RSSI (between -127 and +20 dBm)
    int8_t rssi;
    /// Primary PHY (1:1M, 3:Coded)
    uint8_t phy_prim;
    /// Secondary PHY (0:No packet on secondary phy, 1:1M, 2:2M, 3:Coded)
    uint8_t phy_second;
    /// Advertising SID
    /// Valid only for periodic advertising report
    uint8_t adv_sid;
    /// Periodic advertising interval (in unit of 1.25ms, min is 7.5ms)
    /// Valid only for periodic advertising report
    uint16_t period_adv_intv;
    /// Report length
    uint16_t length;
    /// Report
    uint8_t data[__ARRAY_EMPTY];
} ble_gap_ind_ext_adv_report_t;

/// Device name
typedef struct {
    /// Name length
    uint16_t value_length;
    /// Name value (starting from offset to maximum length for BLE_GAP_DEV_NAME
    /// request)
    uint8_t value[__ARRAY_EMPTY];
} ble_gap_dev_name_t;

typedef struct {
    uint8_t con_idx;
    ble_gap_dev_name_t param;
} ble_gap_le_dev_name_t;

typedef struct {
    uint8_t con_idx;
    /// Appearance Icon
    uint16_t appearance;
} ble_gap_le_appearance_t;

/// Peripheral preference parameters
typedef struct {
    /// Connection interval minimum
    uint16_t con_intv_min;
    /// Connection interval maximum
    uint16_t con_intv_max;
    /// Peripheral latency
    uint16_t periph_latency;
    /// Connection supervision timeout multiplier
    uint16_t con_timeout;
} ble_gap_periph_pref_t;

typedef struct {
    uint8_t con_idx;
    ble_gap_periph_pref_t param;
} ble_gap_le_periph_pref_t;

typedef struct {
    uint8_t con_idx;
    /// Resolvable Private address only
    uint8_t rslv_priv_addr_only;
} ble_gap_le_rslv_priv_addr_only_t;

/// Peer version info
typedef struct {
    /// Manufacturer name
    uint16_t comp_id;
    /// LMP subversion
    uint16_t lmp_subvers;
    /// LMP version
    uint8_t lmp_vers;
} ble_gap_peer_version_t;

typedef struct {
    uint8_t con_idx;
    ble_gap_peer_version_t param;
} ble_gap_le_peer_version_t;

/// Peer features info
typedef struct {
    /// 8-byte array for LE features
    uint8_t features[BLE_GAP_LE_FEATS_LEN];
} ble_gap_peer_features_t;

typedef struct {
    uint8_t con_idx;
    ble_gap_peer_features_t param;
} ble_gap_le_peer_features_t;

/// Ongoing connection RSSI
typedef struct {
    /// RSSI value
    int8_t rssi;
} ble_gap_con_rssi_t;

typedef struct {
    uint8_t con_idx;
    ble_gap_con_rssi_t param;
} ble_gap_le_con_rssi_t;

/// Channel map structure
typedef struct {
    /// 5-byte channel map array
    uint8_t map[BLE_GAP_LE_CHNL_MAP_LEN];
} ble_chnl_map_t;

/// Ongoing connection Channel Map
typedef struct {
    /// Channel map value
    ble_chnl_map_t ch_map;
} ble_gap_con_channel_map_t;

typedef struct {
    uint8_t con_idx;
    ble_gap_con_channel_map_t param;
} ble_gap_le_con_channel_map_t;

/// LE Ping
typedef struct {
    /// Authenticated payload timeout
    uint16_t timeout;
} ble_gap_le_ping_to_val_t;

typedef struct {
    uint8_t con_idx;
    ble_gap_le_ping_to_val_t param;
} ble_gap_le_le_ping_to_val_t;

/// Active link PHY configuration. Triggered when configuration is read or
/// during an update.
typedef struct {
    /// LE PHY for data transmission.
    ble_gap_phy_val_t tx_phy;
    /// LE PHY for data reception.
    ble_gap_phy_val_t rx_phy;
} ble_gap_le_phy_t;

typedef struct {
    uint8_t con_idx;
    ble_gap_le_phy_t param;
} ble_gap_le_le_phy_t;

/// Channel selection algorithm
typedef struct {
    /// Used channel selection algorithm
    uint8_t chan_sel_algo;
} ble_gap_chan_sel_algo_t;

typedef struct {
    uint8_t con_idx;
    ble_gap_chan_sel_algo_t param;
} ble_gap_le_chan_sel_algo_t;

/// Response data of @ref ble_gapc_get_link_info
typedef struct {
    /// Get information type.
    ble_gap_link_info_type_t type;
    union {
	/// Data for BLE_GAP_GET_PEER_NAME type
	ble_gap_le_dev_name_t name;
	/// Data for BLE_GAP_GET_PEER_APPEARANCE type
	ble_gap_le_appearance_t appearance;
	/// Data for BLE_GAP_GET_PEER_PERIPH_PREF_PARAMS type
	ble_gap_le_periph_pref_t periph_pref;
	/// Data for BLE_GAP_GET_ADDR_RESOL_SUPP type
	ble_gap_le_rslv_priv_addr_only_t rslv_priv_addr_only;
	/// Data for BLE_GAP_GET_PEER_VERSION type
	ble_gap_le_peer_version_t peer_ver;
	/// Data for BLE_GAP_GET_PEER_FEATURES type
	ble_gap_le_peer_features_t peer_feat;
	/// Data for BLE_GAP_GET_CON_RSSI type
	ble_gap_le_con_rssi_t con_rssi;
	/// Data for BLE_GAP_GET_CON_CHANNEL_MAP type
	ble_gap_le_con_channel_map_t con_chnl_map;
	/// Data for BLE_GAP_GET_LE_PING_TO type
	ble_gap_le_le_ping_to_val_t le_ping_to;
	/// Data for BLE_GAP_GET_PHY type
	ble_gap_le_le_phy_t le_phy;
	/// Data for BLE_GAP_GET_CHAN_SEL_ALGO type
	ble_gap_le_chan_sel_algo_t chan_sel_algo;
    };
} ble_gap_link_info_t;

typedef struct {
    /// Activity identifier
    uint8_t actv_idx;
    /// Activity stop reason
    ble_err_code_t reason;
    /// In case of periodic advertising, indicate if periodic advertising
    /// has been stopped
    uint8_t per_adv_stop;
} ble_gap_ind_stop_t;

typedef struct {
    /// Connection handle
    uint16_t conhdl;
    /// Connection interval
    uint16_t con_interval;
    /// Connection latency
    uint16_t con_latency;
    /// Supervision timeout
    uint16_t sup_to;
    /// Clock accuracy
    uint8_t clk_accuracy;
    /// Peer address type
    uint8_t peer_addr_type;
    /// Peer BT address
    ble_bdaddr_t peer_addr;
    /// Role of device in connection (0 = Central / 1 = Peripheral)
    uint8_t role;
} ble_gap_ind_con_est_t;

typedef struct {
    /// Connection index
    uint8_t conidx;
    /// Connection parameter
    ble_gap_ind_con_est_t param;
} ble_gap_ind_le_con_est_t;

/// Long Term Key information
typedef struct {
    /// Long Term Key
    ble_gap_key_t ltk;
    /// Encryption Diversifier
    uint16_t ediv;
    /// Random Number
    ble_rand_nb_t randnb;
    /// Encryption key size (7 to 16)
    uint8_t key_size;
} ble_gap_ltk_t;

typedef struct {
    /// Connection index
    uint8_t conidx;
    /// Long Term Key information
    ble_gap_ltk_t ltk;
} ble_gap_ind_le_ltk_t;

typedef struct {
    /// Connection index
    uint8_t conidx;
} ble_gap_ind_le_repeated_attempt_t;

/// Authentication mask
typedef enum {
    /// No Flag set
    BLE_GAP_AUTH_NONE = 0,
    /// Bond authentication
    BLE_GAP_AUTH_BOND = (1 << 0),
    /// Man In the middle protection
    BLE_GAP_AUTH_MITM = (1 << 2),
    /// Secure Connection
    BLE_GAP_AUTH_SEC_CON = (1 << 3),
    /// Key Notification
    BLE_GAP_AUTH_KEY_NOTIF = (1 << 4),
} ble_gap_auth_mask_t;

/// Authentication Requirements
typedef enum {
    /// No MITM No Bonding
    BLE_GAP_AUTH_REQ_NO_MITM_NO_BOND = BLE_GAP_AUTH_NONE,
    /// No MITM Bonding
    BLE_GAP_AUTH_REQ_NO_MITM_BOND = BLE_GAP_AUTH_BOND,
    /// MITM No Bonding
    BLE_GAP_AUTH_REQ_MITM_NO_BOND = BLE_GAP_AUTH_MITM,
    /// MITM and Bonding
    BLE_GAP_AUTH_REQ_MITM_BOND = BLE_GAP_AUTH_MITM | BLE_GAP_AUTH_BOND,
    /// SEC_CON, No MITM and No Bonding
    BLE_GAP_AUTH_REQ_NO_MITM_SEC_CON_NO_BOND = BLE_GAP_AUTH_SEC_CON,
    /// SEC_CON, No MITM and Bonding
    BLE_GAP_AUTH_REQ_NO_MITM_SEC_CON_BOND = BLE_GAP_AUTH_SEC_CON |
	BLE_GAP_AUTH_BOND,
    /// SEC_CON, MITM and No Bonding
    BLE_GAP_AUTH_REQ_MITM_SEC_CON_NO_BOND = BLE_GAP_AUTH_SEC_CON |
	BLE_GAP_AUTH_MITM,
    /// SEC_CON, MITM and Bonding
    BLE_GAP_AUTH_REQ_MITM_SEC_CON_BOND = BLE_GAP_AUTH_SEC_CON |
	BLE_GAP_AUTH_MITM | BLE_GAP_AUTH_BOND,

    /// Mask of  authentication features without reserved flag
    BLE_GAP_AUTH_REQ_MASK = 0x1F
} ble_gap_auth_t;

typedef enum {
    /// Unauthenticated pairing achieved but without bond data
    /// (meaning-less for connection confirmation)
    BLE_GAP_PAIRING_UNAUTH = BLE_GAP_AUTH_NONE,
    /// Authenticated pairing achieved but without bond data
    /// (meaning-less for connection confirmation)
    BLE_GAP_PAIRING_AUTH = BLE_GAP_AUTH_MITM,
    /// Secure connection pairing achieved but without bond data
    /// (meaning-less for connection confirmation)
    BLE_GAP_PAIRING_SECURE_CON = BLE_GAP_AUTH_SEC_CON | BLE_GAP_AUTH_MITM,

    /// No pairing performed with peer device
    /// (meaning-less for connection confirmation)
    BLE_GAP_PAIRING_NO_BOND = BLE_GAP_AUTH_NONE,
    /// Peer device bonded through an unauthenticated pairing.
    BLE_GAP_PAIRING_BOND_UNAUTH = BLE_GAP_AUTH_BOND,
    /// Peer device bonded through an authenticated pairing.
    BLE_GAP_PAIRING_BOND_AUTH = BLE_GAP_AUTH_MITM | BLE_GAP_AUTH_BOND,
    /// Peer device bonded through a secure connection pairing pairing.
    BLE_GAP_PAIRING_BOND_SECURE_CON = BLE_GAP_AUTH_SEC_CON | BLE_GAP_AUTH_MITM |
	BLE_GAP_AUTH_BOND,

    /// Pairing with bond data present Bit
    BLE_GAP_PAIRING_BOND_PRESENT_BIT = 0x01,
    BLE_GAP_PAIRING_BOND_PRESENT_POS = 0x00,
} ble_gap_pairing_level_t;

typedef struct {
    /// Connection handle
    uint8_t conidx;
    /// Error code
    ble_err_code_t reason;
    /// Pairing security level. (Valid if reason == BLE_ERR_NO_ERROR)
    ble_gap_pairing_level_t pairing_lvl;
    /// LTK is exchanged. (Valid if reason == BLE_ERR_NO_ERROR)
    bool ltk_present;
} ble_gap_ind_le_pair_end_t;

typedef struct {
    /// Connection handle
    uint16_t conhdl;
    /// Reason of disconnection
    ble_err_code_t reason;
} ble_gap_ind_discon_t;

typedef struct {
    uint8_t conidx;
    ble_gap_ind_discon_t param;
} ble_gap_ind_le_discon_t;

/// Privacy mode type
typedef enum {
    /// Network privacy mode
    BLE_GAP_PRIV_TYPE_NETWORK,
    /// Device privacy mode
    BLE_GAP_PRIV_TYPE_DEVICE,
} ble_gap_priv_type_t;

/// Resolving list device information
typedef struct {
    /// Device identity
    ble_gap_bdaddr_t addr;
    /// Privacy Mode
    ble_gap_priv_type_t priv_mode;
    /// Peer IRK
    uint8_t peer_irk[BLE_GAP_KEY_LEN];
    /// Local IRK
    uint8_t local_irk[BLE_GAP_KEY_LEN];
} ble_gap_ral_dev_info_t;

typedef struct {
    /// Connection interval used on this connection, unit:1.25 ms
    uint16_t con_interval;
    /// Peripheral latency for the connection in number of connection events,
    /// range: 0x0000 to 0x01F3
    uint16_t con_latency;
    /// Supervision timeout for this connection, unit: 10ms
    uint16_t sup_to;
} ble_gap_ind_con_update_t;

typedef struct {
    uint8_t conidx;
    ble_gap_ind_con_update_t param;
} ble_gap_ind_le_con_update_t;

typedef enum {
    /// Device name
    BLE_GAP_DEV_NAME,
    /// Device external appearance
    BLE_GAP_DEV_APPEARANCE,
    /// Peripheral preferred connection parameters
    BLE_GAP_DEV_PERIPH_PREF_PARAMS,
    /// Central address resolution supported
    BLE_GAP_DEV_CTL_ADDR_RESOL,
    /// Device database hash value
    BLE_GAP_DEV_DB_HASH,
    /// Resolvable private addresss as local addresss only
    BLE_GAP_DEV_RSLV_PRIV_ADDR_ONLY,
    /// Maximum device info parameter
    BLE_GAP_DEV_INFO_MAX,
} ble_gap_dev_info_t;

typedef union {
    /// Device name
    ble_gap_dev_name_t name;
    /// Appearance Icon
    uint16_t appearance;
} ble_gap_set_dev_info_t;

typedef struct {
    /// Requested device information
    ble_gap_dev_info_t req_type;
    /// Token value
    uint16_t token;
    /// Device information data
    ble_gap_set_dev_info_t info;
} ble_gap_ind_set_dev_req_t;

typedef struct {
    uint8_t conidx;
    ble_gap_ind_set_dev_req_t param;
} ble_gap_ind_le_set_dev_req_t;

typedef struct {
    /// true to accept connection parameters, false else.
    bool accept;
    /// Minimum length of connection event needed for this LE connection in
    /// 0.625 ms.
    uint16_t ce_len_min;
    /// Maximum length of connection event needed for this LE connection in
    /// 0.625 ms.
    uint16_t ce_len_max;
} ble_gapc_param_update_cfm_t;

typedef struct {
    /// Connection interval minimum in 1.25 ms
    uint16_t intv_min;
    /// Connection interval maximum in 1.25 ms
    uint16_t intv_max;
    /// Latency
    uint16_t latency;
    /// Supervision timeout in 10 ms
    uint16_t time_out;
} ble_gap_ind_param_update_req_t;

typedef struct {
    uint8_t conidx;
    ble_gap_ind_param_update_req_t param;
} ble_gap_ind_le_param_update_req_t;

typedef struct {
    /// PHY updated
    ble_gap_le_phy_t phy;
} ble_gap_ind_le_phy_t;

typedef struct {
    uint8_t con_idx;
    ble_gap_ind_le_phy_t param;
} ble_gap_ind_le_le_phy_t;

typedef struct {
    /// Channel selection algorithm updated
    ble_gap_chan_sel_algo_t algo;
} ble_gap_ind_chan_sel_algo_t;

typedef struct {
    uint8_t con_idx;
    ble_gap_ind_chan_sel_algo_t param;
} ble_gap_ind_le_chan_sel_algo_t;

/// Additional advertising parameters
typedef struct {
    /// Advertising duration (in unit of 10ms). 0 means that advertising
    /// continues until the host disable it
    uint16_t duration;
    /// Maximum number of extended advertising events the controller shall
    /// attempt to send prior to terminating the extending advertising Valid
    /// only if extended advertising
    uint8_t max_adv_evt;
} ble_gapm_adv_param_t;

/// Scan window operation parameters
typedef struct {
    /// Scan interval
    uint16_t scan_intv;
    /// Scan window
    uint16_t scan_wd;
} ble_gapm_scan_wd_op_param_t;

/// Scanning types
typedef enum {
    /// General discovery
    BLE_GAPM_SCAN_TYPE_GEN_DISC,
    /// Limited discovery
    BLE_GAPM_SCAN_TYPE_LIM_DISC,
    /// Observer
    BLE_GAPM_SCAN_TYPE_OBSERVER,
    /// Selective observer
    BLE_GAPM_SCAN_TYPE_SEL_OBSERVER,
    /// Connectable discovery
    BLE_GAPM_SCAN_TYPE_CONN_DISC,
    /// Selective connectable discovery
    BLE_GAPM_SCAN_TYPE_SEL_CONN_DISC,
} ble_gapm_scan_type_t;

/// Scanning properties bit field bit value
typedef enum {
    /// Scan advertisement on the LE 1M PHY
    BLE_GAPM_SCAN_PROP_PHY_1M_BIT = (1 << 0),
    /// Scan advertisement on the LE Coded PHY
    BLE_GAPM_SCAN_PROP_PHY_CODED_BIT = (1 << 1),
    /// Active scan on LE 1M PHY (Scan Request PDUs may be sent)
    BLE_GAPM_SCAN_PROP_ACTIVE_1M_BIT = (1 << 2),
    /// Active scan on LE Coded PHY (Scan Request PDUs may be sent)
    BLE_GAPM_SCAN_PROP_ACTIVE_CODED_BIT = (1 << 3),
    /// Accept directed advertising packets if we use a RPA and target address
    /// cannot be solved by the controller
    BLE_GAPM_SCAN_PROP_ACCEPT_RPA_BIT = (1 << 4),
    /// Filter truncated advertising or scan response reports
    BLE_GAPM_SCAN_PROP_FILT_TRUNC_BIT = (1 << 5),
} ble_gapm_scan_prop_t;

/// Filtering policy for duplicated packets
typedef enum {
    /// Disable filtering of duplicated packets
    BLE_GAPM_DUP_FILT_DIS,
    /// Enable filtering of duplicated packets
    BLE_GAPM_DUP_FILT_EN,
    /// Enable filtering of duplicated packets, reset for each scan period
    BLE_GAPM_DUP_FILT_EN_PERIOD,
} ble_gapm_dup_filter_pol_t;

/// Scanning parameters
typedef struct {
    /// Type of scanning to be started
    ble_gapm_scan_type_t type;
    /// Properties for the scan procedure
    ble_gapm_scan_prop_t prop;
    /// Duplicate packet filtering policy
    ble_gapm_dup_filter_pol_t dup_filt_pol;
    /// Reserved for future use
    uint8_t rsvd;
    /// Scan window opening parameters for LE 1M PHY
    ble_gapm_scan_wd_op_param_t scan_param_1m;
    /// Scan window opening parameters for LE Coded PHY
    ble_gapm_scan_wd_op_param_t scan_param_coded;
    /// Scan duration (in unit of 10ms). 0 means that the controller will scan
    /// continuously until reception of a stop command from the application
    uint16_t duration;
    /// Scan period (in unit of 1.28s). Time interval between two consequent
    /// starts of a scan duration by the controller. 0 means that the scan
    /// procedure is not periodic
    uint16_t period;
} ble_gapm_scan_param_t;

/// Initiating types
typedef enum {
    /// Direct connection establishment, establish a connection with an
    /// indicated device
    BLE_GAPM_INIT_TYPE_DIRECT_CONN_EST,
    /// Automatic connection establishment, establish a connection with all
    /// devices whose address is present in the white list
    BLE_GAPM_INIT_TYPE_AUTO_CONN_EST,
    /// Name discovery, Establish a connection with an indicated device in order
    /// to read content of its Device Name characteristic. Connection is closed
    /// once this operation is stopped.
    BLE_GAPM_INIT_TYPE_NAME_DISC,
} ble_gapm_init_type_t;

/// Initiating properties
typedef enum {
    /// Scan connectable advertisements on the LE 1M PHY. Connection parameters
    /// for the LE 1M PHY are provided
    BLE_GAPM_INIT_PROP_1M_BIT = (1 << 0),
    /// Connection parameters for the LE 2M PHY are provided
    BLE_GAPM_INIT_PROP_2M_BIT = (1 << 1),
    /// Scan connectable advertisements on the LE Coded PHY. Connection
    /// parameters for the LE Coded PHY are provided
    BLE_GAPM_INIT_PROP_CODED_BIT = (1 << 2),
} ble_gapm_init_prop_t;

/// Connection parameters
typedef struct {
    /// Minimum value for the connection interval (in unit of 1.25ms). Shall be
    /// less than or equal to conn_intv_max value. Allowed range is 7.5ms to 4s.
    uint16_t conn_intv_min;
    /// Maximum value for the connection interval (in unit of 1.25ms). Shall be
    /// greater than or equal to conn_intv_min value. Allowed range is 7.5ms to
    /// 4s.
    uint16_t conn_intv_max;
    /// Slave latency. Number of events that can be missed by a connected slave
    /// device
    uint16_t conn_latency;
    /// Link supervision timeout (in unit of 10ms). Allowed range is 100ms to
    /// 32s
    uint16_t supervision_to;
    /// Recommended minimum duration of connection events (in unit of 625us)
    uint16_t ce_len_min;
    /// Recommended maximum duration of connection events (in unit of 625us)
    uint16_t ce_len_max;
} ble_gapm_conn_param_t;

/// Initiating parameters
typedef struct {
    /// Initiating type
    ble_gapm_init_type_t type;
    /// Properties for the initiating procedure
    ble_gapm_init_prop_t prop;
    /// Timeout for automatic connection establishment (in unit of 10ms). Cancel
    /// the procedure if not all indicated devices have been connected when the
    /// timeout occurs. 0 means there is no timeout
    uint16_t conn_to;
    /// Scan window opening parameters for LE 1M PHY
    ble_gapm_scan_wd_op_param_t scan_param_1m;
    /// Scan window opening parameters for LE Coded PHY
    ble_gapm_scan_wd_op_param_t scan_param_coded;
    /// Connection parameters for LE 1M PHY
    ble_gapm_conn_param_t conn_param_1m;
    /// Connection parameters for LE 2M PHY
    ble_gapm_conn_param_t conn_param_2m;
    /// Connection parameters for LE Coded PHY
    ble_gapm_conn_param_t conn_param_coded;
    /// Address of peer device in case white list is not used for connection
    ble_gap_bdaddr_t peer_addr;
} ble_gapm_init_param_t;

/// Periodic advertising information
typedef struct {
    /// Advertiser address information
    ble_gap_bdaddr_t addr;
    /// Advertising SID
    uint8_t adv_sid;
} ble_gapm_period_adv_addr_t;

/// Periodic synchronization types
typedef enum {
    /// Do not use periodic advertiser list for synchronization. Use advertiser
    /// information provided in the ble_gapm_start_per_sync().
    BLE_GAPM_PER_SYNC_TYPE_GENERAL,
    /// Use periodic advertiser list for synchronization
    BLE_GAPM_PER_SYNC_TYPE_SELECTIVE,
    /// Use Periodic advertising sync transfer information send through
    /// connection for synchronization
    BLE_GAPM_PER_SYNC_TYPE_PAST,
} ble_gapm_per_sync_type_t;

/// Bit field of enabled advertising reports
typedef enum {
    /// Periodic advertising reports reception enabled
    BLE_GAPM_REPORT_ADV_EN_BIT = 0x01,
    BLE_GAPM_REPORT_ADV_EN_POS = 0,
    /// BIG Info advertising reports reception enabled
    BLE_GAPM_REPORT_BIGINFO_EN_BIT = 0x02,
    BLE_GAPM_REPORT_BIGINFO_EN_POS = 1,
    /// Periodic advertising reports reception enabled with duplicate filtering
    /// enabled.
    BLE_GAPM_REPORT_ADV_DUP_FIL_EN_BIT = 0x04,
    BLE_GAPM_REPORT_ADV_DUP_FIL_EN_POS = 2,
} ble_gapm_report_en_bf_t;

/// Constant Tone Extension sync filtering type
typedef enum {
    /// Do not sync to packets with an AoA Constant Tone Extension
    BLE_GAPM_CTE_NO_SYNC_WITH_AOA = (1 << 0),
    /// Do not sync to packets with an AoD Constant Tone Extension with 1 us
    /// slots
    BLE_GAPM_CTE_NO_SYNC_WITH_AOD_1US_SLOT = (1 << 1),
    /// Do not sync to packets with an AoD Constant Tone Extension with 2 us
    /// slots
    BLE_GAPM_CTE_NO_SYNC_WITH_AOD_2US_SLOT = (1 << 2),
    /// Do not sync to packets with a type 3 Constant Tone Extension (currently
    /// reserved for future use)
    BLE_GAPM_CTE_NO_SYNC_WITH_TYPE_3 = (1 << 3),
    /// Do not sync to packets without a Constant Tone Extension
    BLE_GAPM_CTE_NO_SYNC_WITHOUT_CTE = (1 << 4),
} ble_gapm_sync_cte_type_t;

/// Periodic synchronization parameters
typedef struct {
    /// Number of periodic advertising that can be skipped after a successful
    /// receive. Maximum authorized value is 499.
    uint16_t skip;
    /// Synchronization timeout for the periodic advertising (in unit of 10ms
    /// between 100ms and 163.84s)
    uint16_t sync_to;
    /// Periodic synchronization type
    ble_gapm_per_sync_type_t type;
    /// Connection index used for periodic sync info reception (only valid for
    /// BLE_GAPM_PER_SYNC_TYPE_PAST)
    uint8_t conidx;
    /// Address of advertiser with which synchronization has to be established
    /// (used only if type is BLE_GAPM_PER_SYNC_TYPE_GENERAL)
    ble_gapm_period_adv_addr_t adv_addr;
    /// Bit field that contains list of reports that are enabled or not.
    ble_gapm_report_en_bf_t report_en_bf;
    /// Type of Constant Tone Extension device should sync on.
    ble_gapm_sync_cte_type_t cte_type;
} ble_gapm_per_sync_param_t;

/// Type of activities that can be created
typedef enum {
    /// Advertising activity
    BLE_GAPM_ACTV_TYPE_ADV,
    /// Scanning activity
    BLE_GAPM_ACTV_TYPE_SCAN,
    /// Initiating activity
    BLE_GAPM_ACTV_TYPE_INIT,
    /// Periodic synchronization activity
    BLE_GAPM_ACTV_TYPE_PER_SYNC,
} ble_gapm_actv_type_t;

typedef struct {
    /// The maximum Tx payload size
    uint16_t max_tx_octets;
    /// The maximum Tx time (unit: us)
    uint16_t max_tx_time;
    /// The maximum Rx payload size
    uint16_t max_rx_octets;
    /// The maximum Rx time (unit: us)
    uint16_t max_rx_time;
} ble_gap_ind_pkt_size_t;

typedef struct {
    uint8_t conidx;
    ble_gap_ind_pkt_size_t param;
} ble_gap_ind_le_pkt_size_t;

typedef struct {
    /// Requested information
    ble_gap_dev_info_t req;
    /// Token value that must be returned in confirmation
    uint16_t token;
    /// Device name data offset
    uint16_t name_offset;
    /// Maximum name length (starting from offset)
    uint16_t max_name_length;
} ble_gap_ind_get_dev_info_req_t;

typedef struct {
    uint8_t conidx;
    ble_gap_ind_get_dev_info_req_t param;
} ble_gap_ind_le_get_dev_info_req_t;

typedef struct {
    /// Encryption status
    ble_err_code_t status;
    /// Pairing security level
    ble_gap_pairing_level_t pairing_lvl;
} ble_gap_ind_encrypt_t;

typedef struct {
    uint8_t conidx;
    ble_gap_ind_encrypt_t param;
} ble_gap_ind_le_encrypt_t;

typedef struct {
    /// Pairing security level
    ble_gap_pairing_level_t pairing_lvl;
} ble_gap_encrypt_t;

typedef struct {
    uint8_t conidx;
    ble_gap_encrypt_t param;
} ble_gap_le_encrypt_t;

typedef enum {
    /// Passkey entry started
    BLE_GAP_PASSKEY_ENTRY_STARTED,
    /// Passkey digit entered
    BLE_GAP_PASSKEY_DIGIT_ENTERED,
    /// Passkey digit erased
    BLE_GAP_PASSKEY_DIGIT_ERASED,
    /// Passkey cleared
    BLE_GAP_PASSKEY_CLEARED,
    /// Passkey entry completed
    BLE_GAP_PASSKEY_ENTRY_COMPLETED,
} ble_gap_notif_type_t;

typedef struct {
    /// Keypress notification type
    ble_gap_notif_type_t keypress_notif_type;
} ble_gap_ind_keypress_notif_t;

typedef struct {
    uint8_t conidx;
    ble_gap_ind_keypress_notif_t param;
} ble_gap_ind_le_keypress_notif_t;

typedef struct {
    /// Requested information
    ble_gap_dev_info_t req;
    /// Status of the confirmation
    ble_err_code_t status;
    /// Token value provided in request indication
    uint16_t token;
    /// Complete value length including offset
    uint16_t complete_length;
    union {
	/// Data for BLE_GAP_DEV_NAME request
	ble_gap_dev_name_t name;
	/// Data for BLE_GAP_DEV_APPEARANCE request
	uint16_t appearance;
	/// Data for BLE_GAP_DEV_PERIPH_PREF_PARAMS request
	ble_gap_periph_pref_t periph_pref;
	/// Data for BLE_GAP_DEV_CTL_ADDR_RESOL request
	uint8_t ctl_addr_resol;
	/// Data for BLE_GAP_DEV_DB_HASH request
	uint8_t hash[BLE_GAP_DATABASE_HASH_LEN];
	/// Data for BLE_GAP_DEV_RSLV_PRIV_ADDR_ONLY request
	/// 0: Only Resolvable Private Addresses will be used as local addresses
	/// after bonding; 1-255: Reserved for future use.
	uint8_t rslv_priv_addr_only;
    };
} ble_gap_get_dev_info_cfm_t;

typedef struct {
    /// Internally used
    uint8_t operation;
    /// Status of the request
    ble_err_code_t status;
    /// Connection index
    uint8_t con_idx;
    union {
	/// Data for operation (@see enum ble_gap_link_info_type_t)
	ble_gap_link_info_t info;
	/// Authentication. Data in callback of @ref ble_gap_sec_encrypt_req
	ble_gap_le_encrypt_t encrypt;
    };
} ble_gapc_cmpl_t;

typedef struct {
    /// Internally used
    uint8_t operation;
    /// Status of the request
    ble_err_code_t status;
    /// Extra data
    union {
	/// Random number. Data in callback of @ref ble_gapm_gen_rand.
	ble_rand_nb_t randnb;
	/// Resolved addr
	resl_addr_t resladr;
	/// Activity index. Data in callback of @ref ble_gapm_stop_activity
	uint8_t actv_stop_idx;
	/// Generated address which is returned data of
	/// @ref ble_gapm_gen_rand_addr
	ble_bdaddr_t randadr;
	/// Generated encrypted data which is returned data of
	/// @ref ble_gapm_enc_block
	uint8_t enc_result[BLE_GAP_KEY_LEN];
	/// Number of received packets. Data in callback of
	/// @ref ble_gapm_le_test_stop
	uint16_t nb_packet_received;
	/// Periodic sync activity index which is returned data of
	/// @ref ble_gapm_create_persync_activity
	uint8_t persync_act_idx;
	/// Scan activity index which is returned data of
	/// @ref ble_gapm_create_scan_activity
	uint8_t scan_act_idx;
	/// Initiating activity index which is returned data of
	/// @ref ble_gapm_create_init_activity
	uint8_t init_act_idx;
	/// ADV creation information. Data in callback of
	/// @ref ble_gapm_create_adv_activity.
	struct {
	    /// ADV identifier
	    uint8_t adv_idx;
	    /// Selected TX power for ADV activity
	    int8_t tx_pwr;
	} adv_created;
    };
} ble_gapm_cmpl_t;

/// Invalid connection index
#define BLE_GAP_INVALID_CONIDX 0xFF

/// GAP event
typedef enum {
    /// Indication of ADV stop
    BLE_GAP_EID_IND_ADV_STOP,
    /// Indication of Scan stop
    BLE_GAP_EID_IND_SCAN_STOP,
    /// Indication of initiating stop
    BLE_GAP_EID_IND_INIT_STOP,
    /// Indication of periodic sync stop
    BLE_GAP_EID_IND_PER_SYNC_STOP,
    /// Indication of extended advertising report
    BLE_GAP_EID_IND_EXT_ADV_REPORT,
    /// Indication of connection established
    BLE_GAP_EID_IND_CON_EST,
    /// Indication of connection disconnected
    BLE_GAP_EID_IND_DISCON,
    /// Indication of LTK
    BLE_GAP_EID_IND_LTK,
    /// Indication of connection parameter updated
    BLE_GAP_EID_IND_CON_UPDATE,
    /// Indication of set device information request
    BLE_GAP_EID_IND_SET_DEV_INFO_REQ,
    /// Pairing end
    BLE_GAP_EID_IND_PAIR_END,
    /// Indication of parameter updating request
    BLE_GAP_EID_IND_PARAM_UPDATE_REQ,
    /// Indication of LE PHY
    BLE_GAP_EID_IND_LE_PHY,
    /// Indication of channel selection algorithm
    BLE_GAP_EID_IND_CHAN_SEL_ALGO,
    /// Indication of LE packet size
    BLE_GAP_EID_IND_PKT_SIZE,
    /// Indication of getting device information request
    BLE_GAP_EID_IND_GET_DEV_INFO_REQ,
    /// Indication of encrypt
    BLE_GAP_EID_IND_ENCRYPT,
    /// Indicatin of repeated attempt
    BLE_GAP_EID_IND_REPEATED_ATTEMPT,
    /// Indicatin of keypress notification
    BLE_GAP_EID_IND_KEYPRESS_NOTIFICATION,
} ble_gap_eid_t;

typedef struct {
    /// Event ID
    ble_gap_eid_t eid;
    union {
	/// Data for BLE_GAP_EID_IND_ADV_STOP event.
	ble_gap_ind_stop_t ind_adv_stop;
	/// Data for BLE_GAP_EID_IND_SCAN_STOP event.
	ble_gap_ind_stop_t ind_scan_stop;
	/// Data for BLE_GAP_EID_IND_INIT_STOP event.
	ble_gap_ind_stop_t ind_init_stop;
	/// Data for BLE_GAP_EID_IND_PER_SYNC_STOP event.
	ble_gap_ind_stop_t ind_per_sync_stop;
	/// Data for BLE_GAP_EID_IND_EXT_ADV_REPORT event.
	ble_gap_ind_ext_adv_report_t ind_ext_adv_rpt;
	/// Data for BLE_GAP_EID_IND_CON_EST event.
	ble_gap_ind_le_con_est_t ind_con_est;
	/// Data for BLE_GAP_EID_IND_DISCON event.
	ble_gap_ind_le_discon_t ind_discon;
	/// Data for BLE_GAP_EID_IND_LTK event.
	ble_gap_ind_le_ltk_t ind_ltk;
	/// Data for BLE_GAP_EID_IND_CON_UPDATE event.
	ble_gap_ind_le_con_update_t ind_con_update;
	// Data for BLE_GAP_EID_IND_SET_DEV_INFO_REQ event.
	ble_gap_ind_le_set_dev_req_t ind_set_dev_req;
	/// Data for BLE_GAP_EDI_IND_PAIR_END
	ble_gap_ind_le_pair_end_t ind_pair_end;
	/// Data for BLE_GAP_EID_IND_PARAM_UPDATE_REQ event.
	ble_gap_ind_le_param_update_req_t ind_param_update_req;
	/// Data for BLE_GAP_EID_IND_LE_PHY event.
	ble_gap_ind_le_le_phy_t ind_le_phy;
	/// Data for BLE_GAP_EID_IND_CHAN_SEL_ALGO event.
	ble_gap_ind_le_chan_sel_algo_t ind_sel_algo;
	/// Data for BLE_GAP_EID_IND_PKT_SIZE event.
	ble_gap_ind_le_pkt_size_t ind_pkt_size;
	/// Data for BLE_GAP_EID_IND_GET_DEV_INFO_REQ event.
	ble_gap_ind_le_get_dev_info_req_t ind_get_dev_info_req;
	/// Data for BLE_GAP_EID_IND_ENCRYPT event.
	ble_gap_ind_le_encrypt_t ind_encrypt;
	/// Data for BLE_GAP_EID_IND_REPEATED_ATTEMPT event.
	ble_gap_ind_le_repeated_attempt_t ind_repeated_attempt;
	/// Data for BLE_GAP_EID_IND_KEYPRESS_NOTIFICATION event.
	ble_gap_ind_le_keypress_notif_t ind_keypress_notif;
    };
} ble_gap_evt_t;

/// Own BD address source of the device
typedef enum {
    /// Public or Private Static Address
    BLE_OWN_STATIC_ADDR,
    /// Generated resolvable private random address
    BLE_OWN_GEN_RSLV_ADDR,
    /// Generated non-resolvable private random address
    BLE_OWN_GEN_NON_RSLV_ADDR,
} ble_own_addr_t;

/// GAPC command complete callback prototype
/// @param[in] conidx Connection index.
/// @param[in] parm Parameter returned.
/// @param[in] ctx Context provided from calling API.
typedef void (*gapc_cmpl_cb)(uint8_t conidx, struct gapc_cmp_evt const *parm,
    void const *ctx);

/// GAPC message
/// @param[in] id message id
/// @param[in] conidx The connection index
/// @param[in] is_bcast Specify the message is broadcast or not
/// @param[in] parm message parameter
typedef void (*gapc_ind)(enum gapc_msg_id id, uint8_t conidx, bool is_bcast,
    void const *parm);

/// GAPM message callback
/// @param[in] id message id
/// @param[in] parm message parameter
typedef void (*gapm_ind)(enum gapm_msg_id id, void const *parm);

/// GAPM add profile callback prototype
/// @param[in] parm Parameter returned.
/// @param[in] ctx Context provided from calling API.
typedef void (*gapm_profile_add_cb)(void *parm, void const *ctx);

// FIXME: please remove comment below after coverting process is done.
// Coverting mapping for process of cleaning up violation of abstraction:
//| incument            | succeesor            |
//|=====================+======================|
//| gapc_cmpl_cb        | ble_gapc_cmd_cb      |
//| gapm_cmp_evt_t      | ble_gapm_cmpl_t      |
//| struct gapc_cmp_evt | ble_gapc_cmpl_t      |
//| ble_gapm_reg_ind    | ble_gap_evt_func_reg |
//| ble_gapc_reg_ind    | ble_gap_evt_func_reg |
//| gapc_ind            | ble_gap_evt_fn       |
//| gapm_ind            | ble_gap_evt_fn       |
// The incumbent functions(structs) would be totally replaced finally.

/// GAPC command complete callback prototype
/// @param[in] conidx Connection index.
/// @param[in] parm Parameter returned.
/// @param[in] ctx Context provided from calling API.
typedef void (*ble_gapc_cmd_cb)(uint8_t conidx, ble_gapc_cmpl_t const *parm,
    void const *ctx);

/// GAPM command complete callback prototype
/// @param[in] parm Parameter returned.
/// @param[in] ctx Context provided from calling API.
typedef void (*ble_gapm_cmd_cb)(ble_gapm_cmpl_t const *parm, void const *ctx);

/// GAP event callback function
/// @param[in] event Event parameter
/// @return True if processed. If return value is false, the event will be sent
/// to next registered function.
typedef bool (*ble_gap_evt_fn)(ble_gap_evt_t const *event);

/*
 * MACROS
 *******************************************************************************
 */

/// Invalid bond index
#define BLE_GAP_INVALID_BOND (-1)


/*
 * GLOBAL C API
 *******************************************************************************
 */
/**
 *******************************************************************************
 * @brief Register ble gap event callback
 *
 * @param[in] pri Priority for service order. 0 is the highest.
 * @param[in] name Name of this event func.
 * @param[in] fn Event function
 *******************************************************************************
 */
void ble_gap_evt_func_reg(uint8_t pri, ble_gap_evt_reg_name_t name,
    ble_gap_evt_fn fn);

/**
 *******************************************************************************
 * @brief Get gap event handler
 *
 * @param[in] name Name string for event handler.
 * @return Event function. NULL if not found.
 *******************************************************************************
 */
ble_gap_evt_fn ble_gap_evt_func_get(ble_gap_evt_reg_name_t name);

/**
 *******************************************************************************
 * @brief Set device configuration
 *
 * @param[in] cfg device configuration
 * @param[in] cb Complete callback function.
 * @param[in] ctx Context data.
 *******************************************************************************
 */
__NONNULL(1)
void ble_gapm_set_device_config(ble_gap_set_dev_config_t const *cfg,
    ble_gapm_cmd_cb cb, void const *ctx);

/**
 *******************************************************************************
 * @brief Remove gap event handler
 *
 * @param[in] name Name string for event handler.
 * @return Removed callback function. NULL if not found.
 *******************************************************************************
 */
ble_gap_evt_fn ble_gap_evt_func_rm(ble_gap_evt_reg_name_t name);

/**
 *******************************************************************************
 * @brief Generate random number
 *
 * @param[in] cb Complete callback function. The random number will be return in
 * randnb data field of ble_gapm_cmpl_t which is passed as a argument of cb.
 * @param[in] ctx Context data.
 *******************************************************************************
 */
void ble_gapm_gen_rand(ble_gapm_cmd_cb cb, void const *ctx);

/**
 *******************************************************************************
 * @brief Set content of the white list
 * @param[in] count Number of entries to be added in the list. 0 means that list
 * content has to be cleared.
 * @param[in] addrs List of entries to be added in the list.
 * @param[in] cb Command complete callback. NULL means that the caller does not
 * need to be informed after the command completion.
 * @param[in] ctx Context data.
 *******************************************************************************
 */
__NONNULL(2)
void ble_gapm_set_white_list(uint8_t count, ble_gap_bdaddr_t const addrs[],
    ble_gapm_cmd_cb cb, void const *ctx);

/**
 *******************************************************************************
 * @brief Set content of the resolving list
 * @param[in] count Number of entries to be added in the list. 0 means that list
 * content has to be cleared.
 * @param[in] rals List of entries to be added in the list.
 * @param[in] cb Command complete callback. NULL means that the caller does not
 * need to be informed after the command completion.
 * @param[in] ctx Context data.
 *******************************************************************************
 */
void ble_gapm_set_resolving_list(uint8_t count,
    ble_gap_ral_dev_info_t const rals[], ble_gapm_cmd_cb cb, void const *ctx);

/**
 *******************************************************************************
 * @brief Lower slave latency locally
 * @param[in] conidx Connection index.
 * @param[in] latency
 * @param[in] cb Command complete callback
 * @param[in] ctx Context data.
 *******************************************************************************
 */
void ble_gapc_lower_slave_latency_locally(uint8_t conidx, uint16_t latency,
    ble_gapc_cmd_cb cb, void const *ctx);

/**
 *******************************************************************************
 * @brief Set the preferred slave event duration (for slave role configuration)
 * @param[in] conidx Connection index.
 * @param[in] dur Preferred event duration that the controller should use on a
 * connection (N * 0.625 ms)
 * @param[in] single_tx Slave transmits a single packet per connection event
 * (False/True)
 * @param[in] cb Command complete callback
 * @param[in] ctx Context data.
 *******************************************************************************
 */
void ble_gapc_set_prefer_slave_event_duration(uint8_t conidx, uint16_t dur,
    bool single_tx, ble_gapc_cmd_cb cb, void const *ctx);

/**
 *******************************************************************************
 * @brief Start TX direct test mode
 * @param[in] param Test TX parameters.
 * @param[in] cb Command complete callback. NULL means that the caller does not
 * need to be informed after the command completion.
 *******************************************************************************
 */
__NONNULL(1)
void ble_gapm_le_test_tx(ble_gap_test_tx_param_t const *param,
    ble_gapm_cmd_cb cb);

/**
 *******************************************************************************
 * @brief Start RX direct test mode.
 * @param[in] param Test RX parameters.
 * @param[in] cb Command complete callback. NULL means that the caller does not
 * need to be informed after the command completion.
 *******************************************************************************
 */
__NONNULL(1)
void ble_gapm_le_test_rx(ble_gap_test_rx_param_t const *param,
    ble_gapm_cmd_cb cb);

/**
 *******************************************************************************
 * @brief Stop the direct test mode.
 * @param[in] cb Command complete callback.
 *******************************************************************************
 */
__NONNULL_ALL
void ble_gapm_le_test_stop(ble_gapm_cmd_cb cb);

/**
 *******************************************************************************
 * @brief Resolve provided random address using array of Identity Resolution Key
 * (IRK) exchanged.
 * @param[in] addr Resolvable random address to solve.
 * @param[in] nb Number of provided IRK.
 * @param[in] irkarr peer IRK
 * @param[in] cb Command complete callback.
 * @param[in] ctx Context data.
 *******************************************************************************
 */
void ble_gapm_resolv_addr(ble_bdaddr_t addr, uint8_t nb, ble_gap_irk_idx_t irkarr[],
    ble_gapm_cmd_cb cb, void const *ctx);

/**
 *******************************************************************************
 * @brief Generate random address
 * @param[in] addr_type random address type
 * @param[in] cb Command complete or indication callback.
 * @param[in] ctx Context data.
 *******************************************************************************
 */
void ble_gapm_gen_rand_addr(ble_gapm_rand_addr_type_t addr_type,
    ble_gapm_cmd_cb cb, void const *ctx);

/**
 *******************************************************************************
 * @brief Encrypt data
 * @param[in] key 128 bit operand (key)
 * @param[in] data 128 bit operand (data)
 * @param[in] cb Command complete callback.
 * @param[in] ctx Context data.
 *******************************************************************************
 */
void ble_gapm_enc_block(uint8_t const key[BLE_GAP_KEY_LEN],
    uint8_t const data[BLE_GAP_KEY_LEN], ble_gapm_cmd_cb cb, void const *ctx);

/**
 *******************************************************************************
 * @brief Stop an activity
 * @param[in] idx Activity identifier
 * @param[in] ctx Context data.
 * @param[in] cb Command complete callback.
 *******************************************************************************
 */
void ble_gapm_stop_activity(uint8_t idx, void const *ctx, ble_gapm_cmd_cb cb);

/**
 *******************************************************************************
 * @brief Delete activity
 * @param[in] idx Activity identifier.
 * @param[in] ctx Context data.
 * @param[in] cb Command complete callback.
 *******************************************************************************
 */
void ble_gapm_delete_activity(uint8_t idx, void const *ctx, ble_gapm_cmd_cb cb);

/**
 *******************************************************************************
 * @brief Set advertising data
 * @param[in] data_type  ADV data type
 * @param[in] idx Activity identifier.
 * @param[in] len Length of ADV data.
 * @param[in] data ADV data array.
 * @param[in] ctx Context data.
 * @param[in] cb Command complete callback.
 *****************************************************************************
 */
void ble_gapm_set_adv_data(ble_gapm_data_type_t data_type, uint8_t idx,
    uint16_t len, uint8_t const *data, void const *ctx, ble_gapm_cmd_cb cb);

/**
 *******************************************************************************
 * @brief Get link information
 * @param[in] info Operation correspond to information.
 * @param[in] conidx Connection index.
 * @param[in] cb Complete callback function. NULL means that the caller does not
 * need to be informed after the command completion.
 * @param[in] ctx Context data.
 *******************************************************************************
 */
void ble_gapc_get_link_info(uint8_t conidx, ble_gap_link_info_type_t info,
    ble_gapc_cmd_cb cb, void const *ctx);

/**
 *******************************************************************************
 * @brief Set phy. rate
 * @param[in] conidx Connection index.
 * @param[in] tx_phy Tx phy.
 * @param[in] rx_phy Rx phy.
 * @param[in] phy_opt Coded phy. opt.
 * @param[in] cb Complete callback function. NULL means that the caller does not
 * need to be informed after the command completion.
 * @param[in] ctx Context data.
 *******************************************************************************
 */
void ble_gapc_set_phy(uint8_t conidx, ble_gap_phy_mode_t tx_phy,
    ble_gap_phy_mode_t rx_phy, ble_gap_phy_opt_t phy_opt, ble_gapc_cmd_cb cb,
    void const *ctx);

/**
 *******************************************************************************
 * @brief Update connection parameters
 * @param[in] conidx Connection index.
 * @param[in] param Connection parameters.
 * @param[in] cb Complete callback function.
 * @param[in] ctx Context data.
 *******************************************************************************
 */
__NONNULL(2)
void ble_gapc_update_param(uint8_t conidx, ble_gap_conn_param_t const *param,
    ble_gapc_cmd_cb cb, void const *ctx);

/**
 *******************************************************************************
 * @brief Disconnect specific link
 * @param[in] conidx Connection index.
 * @param[in] reason Reason for disconnection. Only allow BLE_HCI_MODULE and
 * BLE_SMP_MODULE type.
 * @param[in] cb Complete callback function.
 * @param[in] ctx Context data.
 *******************************************************************************
 */
void ble_gapc_disconnect(uint8_t conidx, ble_err_code_t reason, ble_gapc_cmd_cb cb,
    void const *ctx);

/**
 *******************************************************************************
 * @brief Set device IRK
 * @param[in] irk IRK array data. Size is BLE_GAP_KEY_LEN(16).
 * @param[in] cb Complete callback function.
 * @param[in] ctx Context data.
 *******************************************************************************
 */
__NONNULL(1)
void ble_gapm_set_irk(uint8_t const irk[BLE_GAP_KEY_LEN], ble_gapm_cmd_cb cb,
    void const *ctx);

/**
 *******************************************************************************
 * @brief Set device information confirmation (corresponding to
 * BLE_GAP_EID_IND_SET_DEV_INFO_REQ event)
 * @param[in] conidx Connection index.
 * @param[in] req_type Request type
 * @param[in] status Status of the request
 * @param[in] token Token value
 *******************************************************************************
 */
void ble_gapc_set_dev_info_cfm(uint8_t conidx, ble_gap_dev_info_t req_type,
    ble_err_code_t status, uint16_t token);

/**
 *******************************************************************************
 * @brief Retrieve connection address information
 * @param[in] conidx Connection index
 * @param[out] addr Pointer to peer addr.
 * @return True if connection exists.
 *******************************************************************************
 */
__NONNULL(2)
bool ble_gapc_get_peer_addr(uint8_t conidx, ble_gap_bdaddr_t *addr);

/**
 *******************************************************************************
 * @brief Confirm reception of BLE_GAP_EID_IND_PARAM_UPDATE_REQ event
 * @param[in] conidx Connection index.
 * @param[in] param Confirmation parameters.
 *******************************************************************************
 */
__NONNULL(2)
void ble_gapc_param_update_cfm(uint8_t conidx,
    ble_gapc_param_update_cfm_t const *param);

/**
 *******************************************************************************
 * @brief Confirm reception of BLE_GAP_EID_IND_GET_DEV_INFO_REQ event
 * @param[in] conidx Connection index.
 * @param[in] param Confirmation parameters.
 *******************************************************************************
 */
__NONNULL(2)
void ble_gapc_get_dev_info_cfm(uint8_t conidx,
    ble_gap_get_dev_info_cfm_t const *param);

/**
 *******************************************************************************
 * @brief Create periodic sync activity
 * @param[in] own_addr_type Own address type
 * @param[in] ctx Context data.
 * @param[in] cb Command complete callback.
 *******************************************************************************
 */
__NONNULL(3)
void ble_gapm_create_persync_activity(ble_own_addr_t own_addr_type,
    void const *ctx, ble_gapm_cmd_cb cb);

/**
 *******************************************************************************
 * @brief Create scan activity
 * @param[in] own_addr_type Own address type
 * @param[in] ctx Context data.
 * @param[in] cb Command complete callback.
 *******************************************************************************
 */
__NONNULL(3)
void ble_gapm_create_scan_activity(ble_own_addr_t own_addr_type,
    void const *ctx, ble_gapm_cmd_cb cb);

/**
 *******************************************************************************
 * @brief Create initiating activity
 * @param[in] own_addr_type Own address type
 * @param[in] ctx Context data.
 * @param[in] cb Command complete callback.
 *******************************************************************************
 */
__NONNULL(3)
void ble_gapm_create_init_activity(ble_own_addr_t own_addr_type,
    void const *ctx, ble_gapm_cmd_cb cb);

/**
 *******************************************************************************
 * @brief Start advertising
 * @param[in] idx Activity identifier.
 * @param[in] dur Advertising duration (in unit of 10ms). 0 means that
 * advertising continues until the application stop actively.
 * @param[in] max_evt  Maximum number of extended advertising events the
 * controller shall attempt to send prior to terminating the extending
 * advertising. Valid only if extended advertising.
 * @param[in] ctx Context data.
 * @param[in] cb Command complete callback. NULL means that the caller does not
 * need to be informed after the command completion.
 *******************************************************************************
 */
void ble_gapm_start_adv(uint8_t idx, uint16_t dur, uint8_t max_evt,
    void const *ctx, ble_gapm_cmd_cb cb);

/**
 *******************************************************************************
 * @brief Start scanning
 * @param[in] idx Activity identifier.
 * @param[in] param Scanning parameters.
 * @param[in] ctx Context data.
 * @param[in] cb Command complete callback. NULL means that the caller does not
 * need to be informed after the command completion.
 *******************************************************************************
 */
__NONNULL(2)
void ble_gapm_start_scan(uint8_t idx, ble_gapm_scan_param_t const *param,
    void const *ctx, ble_gapm_cmd_cb cb);

/**
 *******************************************************************************
 * @brief Start Initiating
 * @param[in] idx Activity identifier.
 * @param[in] param Initiating parameters.
 * @param[in] ctx Context data.
 * @param[in] cb Command complete callback. NULL means that the caller does not
 * need to be informed after the command completion.
 *******************************************************************************
 */
__NONNULL(2)
void ble_gapm_start_init(uint8_t idx, ble_gapm_init_param_t const *param,
    void const *ctx, ble_gapm_cmd_cb cb);

/**
 *******************************************************************************
 * @brief Start periodic synchronization
 * @param[in] idx Activity identifier.
 * @param[in] param Periodic synchronization parameters.
 * @param[in] ctx Context data.
 * @param[in] cb Command complete callback. NULL means that the caller does not
 * need to be informed after the command completion.
 *******************************************************************************
 */
__NONNULL(2)
void ble_gapm_start_per_sync(uint8_t idx,
    ble_gapm_per_sync_param_t const *param, void const *ctx,
    ble_gapm_cmd_cb cb);

/**
 *******************************************************************************
 * @brief Create ADV activity
 * @param[in] own_addr_type Own address type
 * @param[in] param Advertising parameters for advertising creation.
 * @param[in] ctx Context data
 * @param[in] cb Command complete callback.
 *******************************************************************************
 */
__NONNULL(2)
void ble_gapm_create_adv_activity(ble_own_addr_t own_addr_type,
    ble_gapm_adv_create_param_t const *param, void const *ctx,
    ble_gapm_cmd_cb cb);

/**
 *******************************************************************************
 * @brief Get advertising create parameters from Flash NVDS.
 * @param[in] is_wurx True if the adv is wurx.
 * @param[in,out] own_addr_type Own addr type.
 * @param[in,out] create Create parameter
 * @return true for success
 *******************************************************************************
 */
__NONNULL_ALL
bool ble_gapm_get_adv_create_nvds(bool is_wurx, ble_own_addr_t *own_addr_type,
    ble_gapm_adv_create_param_t *create);

#ifdef __cplusplus
}
#endif

///@} ATM_BTFM_BLE_GAP