pinebuds/services/ble_stack/hl/api/gapm_task.h

1442 lines
48 KiB
C
Raw Normal View History

2022-08-15 04:20:27 -05:00
#ifndef _GAPM_TASK_H_
#define _GAPM_TASK_H_
/**
****************************************************************************************
* @addtogroup GAPM_TASK Generic Access Profile Manager Task
* @ingroup GAPM
* @brief Handles ALL messages to/from GAP Manager block.
*
* It handles messages from lower and higher layers not related to an ongoing connection.
*
* @{
****************************************************************************************
*/
/*
* INCLUDE FILES
****************************************************************************************
*/
#include "rwip_task.h" // Task definitions
#include "gap.h"
/*
* DEFINES
****************************************************************************************
*/
/// Offset for List Management Operation Codes
#define GAPM_OP_OFFSET_LIST_MGMT (0x90)
/// Offset for Extended Air Operation Codes
#define GAPM_OP_OFFSET_EXT_AIR (0xA0)
/*
* ENUMERATIONS
****************************************************************************************
*/
/// GAP Manager Message Interface
enum gapm_msg_id
{
/* Default event */
/// Command Complete event
GAPM_CMP_EVT = TASK_FIRST_MSG(TASK_ID_GAPM),
/// Event triggered to inform that lower layers are ready
GAPM_DEVICE_READY_IND,
/* Default commands */
/// Reset link layer and the host command
GAPM_RESET_CMD,
/// Cancel ongoing operation - DEPRECATED
GAPM_CANCEL_CMD,
/* Device Configuration */
/// Set device configuration command
GAPM_SET_DEV_CONFIG_CMD,
/// Set device channel map
GAPM_SET_CHANNEL_MAP_CMD,
/* Local device information */
/// Get local device info command
GAPM_GET_DEV_INFO_CMD,
/// Local device version indication event
GAPM_DEV_VERSION_IND,
/// Local device BD Address indication event
GAPM_DEV_BDADDR_IND,
/// Advertising channel Tx power level
GAPM_DEV_ADV_TX_POWER_IND,
/// Indication containing information about memory usage.
GAPM_DBG_MEM_INFO_IND,
/* White List */
/// White List Management Command - DEPRECATED
GAPM_WHITE_LIST_MGT_CMD,
/// White List Size indication event - DEPRECATED
GAPM_WHITE_LIST_SIZE_IND,
/* Air Operations */
/// Set advertising mode Command - DEPRECATED
GAPM_START_ADVERTISE_CMD,
/// Update Advertising Data Command - On fly update when device is advertising - DEPRECATED, 41
GAPM_UPDATE_ADVERTISE_DATA_CMD,
/// Set Scan mode Command - DEPRECATED
GAPM_START_SCAN_CMD,
/// Advertising or scanning report information event - DEPRECATED
GAPM_ADV_REPORT_IND,
/// Set connection initialization Command - DEPRECATED
GAPM_START_CONNECTION_CMD,
/// Name of peer device indication
GAPM_PEER_NAME_IND,
/// Confirm connection to a specific device (Connection Operation in Selective mode) - DEPRECATED
GAPM_CONNECTION_CFM,
/* Security / Encryption Toolbox */
/// Resolve address command
GAPM_RESOLV_ADDR_CMD,
/// Indicate that resolvable random address has been solved
GAPM_ADDR_SOLVED_IND,
/// Generate a random address.
GAPM_GEN_RAND_ADDR_CMD,
/// Use the AES-128 block in the controller
GAPM_USE_ENC_BLOCK_CMD,
/// AES-128 block result indication
GAPM_USE_ENC_BLOCK_IND,
/// Generate a 8-byte random number
GAPM_GEN_RAND_NB_CMD,
/// Random Number Indication
GAPM_GEN_RAND_NB_IND,
/* Profile Management */
/// Create new task for specific profile, 3355
GAPM_PROFILE_TASK_ADD_CMD,
/// Inform that profile task has been added.
GAPM_PROFILE_ADDED_IND,
/// Indicate that a message has been received on an unknown task
GAPM_UNKNOWN_TASK_IND,
/* Data Length Extension */
/// Suggested Default Data Length indication
GAPM_SUGG_DFLT_DATA_LEN_IND,
/// Maximum Data Length indication
GAPM_MAX_DATA_LEN_IND,
/* Resolving list for controller-based privacy*/
/// Resolving address list management - DEPRECATED
GAPM_RAL_MGT_CMD,
/// Resolving address list size indication - DEPRECATED
GAPM_RAL_SIZE_IND,
/// Resolving address list address indication
GAPM_RAL_ADDR_IND,
/* Set new IRK */
/// Modify current IRK
GAPM_SET_IRK_CMD,
/* LE Protocol/Service Multiplexer Management */
/// Register a LE Protocol/Service Multiplexer command
GAPM_LEPSM_REGISTER_CMD,
/// Unregister a LE Protocol/Service Multiplexer command
GAPM_LEPSM_UNREGISTER_CMD,
/* ************************************************ */
/* ------------ NEW COMMANDS FOR BLE 5 ------------ */
/* ************************************************ */
/* List Management Operations */
/// Get local or peer address
/// @see struct gapm_get_ral_addr_cmd
GAPM_GET_RAL_ADDR_CMD = TASK_FIRST_MSG(TASK_ID_GAPM) + GAPM_OP_OFFSET_LIST_MGMT,
/// Set content of either white list or resolving list or periodic advertiser list
/// @see struct gapm_list_set_wl_cmd
/// @see struct gapm_list_set_ral_cmd
/// @see struct gapm_list_set_pal_cmd
GAPM_LIST_SET_CMD,
/// Indicate size of list indicated in GAPM_GET_DEV_CONFIG_CMD message
/// @see struct gapm_list_size_ind
GAPM_LIST_SIZE_IND,
/* Extended Air Operations */
/// Create an advertising, a scanning, an initiating or a periodic synchronization activity
/// @see struct gapm_activity_create_cmd
/// @see struct gapm_activity_create_adv_cmd
GAPM_ACTIVITY_CREATE_CMD = TASK_FIRST_MSG(TASK_ID_GAPM) + GAPM_OP_OFFSET_EXT_AIR,
/// Start a previously created activity
/// @see struct gapm_activity_start_cmd
GAPM_ACTIVITY_START_CMD,
/// Stop either a given activity or all existing activities
/// @see struct gapm_activity_stop_cmd
GAPM_ACTIVITY_STOP_CMD,
/// Delete either a given activity or all existing activities
/// @see struct gapm_activity_delete_cmd
GAPM_ACTIVITY_DELETE_CMD,
/// Indicate that an activity has well been created
/// @see struct gapm_activity_create_ind
GAPM_ACTIVITY_CREATED_IND,
/// Indicate that an activity has been stopped and can be restarted
/// @see struct gapm_activity_stopped_ind
GAPM_ACTIVITY_STOPPED_IND,
/// Set either advertising data or scan response data or periodic advertising data
/// @see struct gapm_set_adv_data_cmd
GAPM_SET_ADV_DATA_CMD,
/// Indicate reception of an advertising report (periodic or not), a scan response report
/// @see struct gapm_ext_adv_report_ind
GAPM_EXT_ADV_REPORT_IND,
/// Indicate reception of a scan request
/// @see struct gapm_scan_request_ind
GAPM_SCAN_REQUEST_IND,
/// Indicate that synchronization has been successfully established with a periodic advertiser
/// @see struct gapm_sync_established_ind
GAPM_SYNC_ESTABLISHED_IND,
/// Indicate maximum advertising data length supported by controller
/// @see struct gapm_max_adv_data_len_ind
GAPM_MAX_ADV_DATA_LEN_IND,
/// Indicate number of available advertising sets
/// @see struct gapm_nb_adv_sets_ind
GAPM_NB_ADV_SETS_IND,
/* ************************************************ */
/* -------------- Internal usage only ------------- */
/* ************************************************ */
/// Message received to unknown task received
GAPM_UNKNOWN_TASK_MSG,
/* Secure Connections */
/// Request to provide DH Key
GAPM_GEN_DH_KEY_CMD,
/// if the controller do not supp DHK GEN we make it on host..
GAPM_GEN_DH_KEY_ON_HOST_CMD,
/// Indicates the DH Key computation is complete and available
GAPM_GEN_DH_KEY_IND,
/* Internal messages for timer events, not part of API*/
/// Limited discoverable timeout indication - DEPRECATED
GAPM_LIM_DISC_TO_IND,
/// Scan timeout indication - DEPRECATED
GAPM_SCAN_TO_IND,
/// Address renewal timeout indication
GAPM_ADDR_RENEW_TO_IND,
/// Automatic connection establishment timeout indication
GAPM_AUTO_CONN_TO_IND,
/// Renew random private addresses
/// @see struct gapm_actv_addr_renew_cmd
GAPM_ACTV_ADDR_RENEW_CMD,
};
/// GAP Manager operation type - application interface
enum gapm_operation
{
/* No Operation (if nothing has been requested) */
/* ************************************************ */
/// No operation.
GAPM_NO_OP = 0x00,
/* Default operations */
/* ************************************************ */
/// Reset BLE subsystem: LL and HL.
GAPM_RESET,
/// Cancel currently executed operation. - DEPRECATED
GAPM_CANCEL,
/* Configuration operations */
/* ************************************************ */
/// Set device configuration
GAPM_SET_DEV_CONFIG,
/// Set device channel map
GAPM_SET_CHANNEL_MAP,
/* Retrieve device information */
/* ************************************************ */
/// Get Local device version
GAPM_GET_DEV_VERSION,
/// Get Local device BD Address
GAPM_GET_DEV_BDADDR,
/// Get device advertising power level, 7
GAPM_GET_DEV_ADV_TX_POWER,
/* Operation on White list */
/* ************************************************ */
/// Get White List Size.
GAPM_GET_WLIST_SIZE,
/// Add devices in white list. - DEPRECATED
GAPM_ADD_DEV_IN_WLIST,
/// Remove devices form white list. - DEPRECATED
GAPM_RMV_DEV_FRM_WLIST,
/// Clear all devices from white list. - DEPRECATED
GAPM_CLEAR_WLIST,
/* Advertise mode operations */
/* ************************************************ */
/// Start non connectable advertising - DEPRECATED
GAPM_ADV_NON_CONN,
/// Start undirected connectable advertising - DEPRECATED 13
GAPM_ADV_UNDIRECT,
/// Start directed connectable advertising - DEPRECATED
GAPM_ADV_DIRECT,
/// Start directed connectable advertising using Low Duty Cycle - DEPRECATED
GAPM_ADV_DIRECT_LDC,
/// Update on the fly advertising data - DEPRECATED
GAPM_UPDATE_ADVERTISE_DATA,
/* Scan mode operations */
/* ************************************************ */
/// Start active scan operation - DEPRECATED
GAPM_SCAN_ACTIVE,
/// Start passive scan operation - DEPRECATED
GAPM_SCAN_PASSIVE,
/* Connection mode operations */
/* ************************************************ */
/// Direct connection operation - DEPRECATED
GAPM_CONNECTION_DIRECT,
/// Automatic connection operation - DEPRECATED
GAPM_CONNECTION_AUTO,
/// Selective connection operation - DEPRECATED
GAPM_CONNECTION_SELECTIVE,
/// Name Request operation (requires to start a direct connection) - DEPRECATED
GAPM_CONNECTION_NAME_REQUEST,
/* Security / Encryption Toolbox */
/* ************************************************ */
/// Resolve device address
GAPM_RESOLV_ADDR,
/// Generate a random address
GAPM_GEN_RAND_ADDR,
/// Use the controller's AES-128 block
GAPM_USE_ENC_BLOCK,
/// Generate a 8-byte random number
GAPM_GEN_RAND_NB,
/* Profile Management */
/* ************************************************ */
/// Create new task for specific profile , 27
GAPM_PROFILE_TASK_ADD,
/* DEBUG */
/* ************************************************ */
/// Get memory usage
GAPM_DBG_GET_MEM_INFO,
/// Perform a platform reset
GAPM_PLF_RESET,
/* Data Length Extension */
/* ************************************************ */
/// Set Suggested Default LE Data Length
GAPM_SET_SUGGESTED_DFLT_LE_DATA_LEN,
/// Get Suggested Default LE Data Length
GAPM_GET_SUGGESTED_DFLT_LE_DATA_LEN,
/// Get Maximum LE Data Length
GAPM_GET_MAX_LE_DATA_LEN,
/* Operation on Resolving List */
/* ************************************************ */
/// Get resolving address list size
GAPM_GET_RAL_SIZE,
/// Get resolving local address
GAPM_GET_RAL_LOC_ADDR,
/// Get resolving peer address
GAPM_GET_RAL_PEER_ADDR,
/// Add device in resolving address list - DEPRECATED
GAPM_ADD_DEV_IN_RAL,
/// Remove device from resolving address list - DEPRECATED
GAPM_RMV_DEV_FRM_RAL,
/// Clear resolving address list - DEPRECATED
GAPM_CLEAR_RAL,
/* Connection mode operations - cont */
/* ************************************************ */
/// General connection operation - DEPRECATED
GAPM_CONNECTION_GENERAL,
/* Change current IRK */
/* ************************************************ */
/// Set IRK
GAPM_SET_IRK,
/* LE Protocol/Service Multiplexer management */
/* ************************************************ */
/// Register a LE Protocol/Service Multiplexer
GAPM_LEPSM_REG,
/// Unregister a LE Protocol/Service Multiplexer
GAPM_LEPSM_UNREG,
/* Secure Connection - Internal API */
/* ************************************************ */
/// Generate DH_Key
GAPM_GEN_DH_KEY,
/* List Management */
/* ************************************************ */
/// Set content of white list
GAPM_SET_WLIST = GAPM_NO_OP + GAPM_OP_OFFSET_LIST_MGMT,
/// Set content of resolving list
GAPM_SET_RAL,
/// Set content of periodic advertiser list
GAPM_SET_PAL,
/// Get white list size
//GAPM_GET_WHITE_LIST_SIZE,
/// Get resolving list size
//GAPM_GET_RAL_SIZE,
/// Get periodic advertiser list size
GAPM_GET_PAL_SIZE = GAPM_SET_PAL + 3,
/* Extended Air Operations */
/* ************************************************ */
/// Create advertising activity
GAPM_CREATE_ADV_ACTIVITY = GAPM_NO_OP + GAPM_OP_OFFSET_EXT_AIR,
/// Create scanning activity
GAPM_CREATE_SCAN_ACTIVITY,
/// Create initiating activity
GAPM_CREATE_INIT_ACTIVITY,
/// Create periodic synchronization activity
GAPM_CREATE_PERIOD_SYNC_ACTIVITY,
/// Start an activity
GAPM_START_ACTIVITY,
/// Stop an activity
GAPM_STOP_ACTIVITY,
/// Stop all activities
GAPM_STOP_ALL_ACTIVITIES,
/// Delete an activity
GAPM_DELETE_ACTIVITY,
/// Delete all activities
GAPM_DELETE_ALL_ACTIVITIES,
/// Set advertising data
GAPM_SET_ADV_DATA,
/// Set scan response data
GAPM_SET_SCAN_RSP_DATA,
/// Set periodic advertising data
GAPM_SET_PERIOD_ADV_DATA,
/// Get number of available advertising sets
GAPM_GET_NB_ADV_SETS,
/// Get maximum advertising data length supported by the controller
GAPM_GET_MAX_LE_ADV_DATA_LEN,
/// INTERNAL OPERATION - Renew random addresses
GAPM_RENEW_ADDR,
};
/// Device Address type Configuration
enum gapm_addr_type
{
/// Device Address is a Public Static address
GAPM_CFG_ADDR_PUBLIC = 0,
/// Device Address is a Private Static address
GAPM_CFG_ADDR_PRIVATE = 1,
/// Device Address generated using host-based Privacy feature - DEPRECATED
GAPM_CFG_ADDR_HOST_PRIVACY = 2,
/// Device Address generated using controller-based Privacy feature
GAPM_CFG_ADDR_CTNL_PRIVACY = 4,
};
/// Own BD address source of the device
enum gapm_own_addr
{
/// Public or Private Static Address according to device address configuration
GAPM_STATIC_ADDR,
/// Generated resolvable private random address
GAPM_GEN_RSLV_ADDR,
/// Generated non-resolvable private random address
GAPM_GEN_NON_RSLV_ADDR,
};
/// Device Attribute write permission requirement
enum gapm_write_att_perm
{
/// Disable write access
GAPM_WRITE_DISABLE = 0,
/// Enable write access - no authentication required
GAPM_WRITE_NO_AUTH = 1,
/// Write access requires unauthenticated link
GAPM_WRITE_UNAUTH = 2,
/// Write access requires authenticated link
GAPM_WRITE_AUTH = 3,
/// Write access requires secure connected link
GAPM_WRITE_SEC_CON = 4
};
/// Attribute database configuration
/// 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
/// +----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
/// | DBG | RFU | SC |PCP | APP_PERM | NAME_PERM |
/// +----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
/// - Bit [0-2] : Device Name write permission requirements for peer device (@see gapm_write_att_perm)
/// - Bit [3-5] : Device Appearance write permission requirements for peer device (@see gapm_write_att_perm)
/// - Bit [6] : Slave Preferred Connection Parameters present
/// - Bit [7] : Service change feature present in GATT attribute database.
/// - Bit [8-14]: Reserved
/// - Bit [15] : Enable Debug Mode
enum gapm_att_cfg_flag
{
/// Device Name write permission requirements for peer device (@see gapm_write_att_perm)
GAPM_MASK_ATT_NAME_PERM = 0x0007,
GAPM_POS_ATT_NAME_PERM = 0x00,
/// Device Appearance write permission requirements for peer device (@see gapm_write_att_perm)
GAPM_MASK_ATT_APPEARENCE_PERM = 0x0038,
GAPM_POS_ATT_APPEARENCE_PERM = 0x03,
/// Slave Preferred Connection Parameters present in GAP attribute database.
GAPM_MASK_ATT_SLV_PREF_CON_PAR_EN = 0x0040,
GAPM_POS_ATT_SLV_PREF_CON_PAR_EN = 0x06,
/// Service change feature present in GATT attribute database.
GAPM_MASK_ATT_SVC_CHG_EN = 0x0080,
GAPM_POS_ATT_SVC_CHG_EN = 0x07,
/// Service change feature present in GATT attribute database.
GAPM_MASK_ATT_DBG_MODE_EN = 0x8000,
GAPM_POS_ATT_DBG_MODE_EN = 0x0F,
};
/// Pairing mode authorized on the device
/// 7 6 5 4 3 2 1 0
/// +----+----+----+----+----+----+----+----+
/// |KGEN| RFU | SCP| LP |
/// +----+----+----+----+----+----+----+----+
enum gapm_pairing_mode
{
/// No pairing authorized
GAPM_PAIRING_DISABLE = 0,
/// Legacy pairing Authorized
GAPM_PAIRING_LEGACY = (1 << 0),
/// Secure Connection pairing Authorized
GAPM_PAIRING_SEC_CON = (1 << 1),
/// Force re-generation of P256 private and public keys
GAPM_PAIRING_FORCE_P256_KEY_GEN = (1<<7),
};
/// LE Audio Mode Configuration
/// 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
/// +----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
/// | RFU | AM0|
/// +----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
enum gapm_audio_cfg_flag
{
/// LE Audio Mode 0 Supported
GAPM_MASK_AUDIO_AM0_SUP = 0x0001,
GAPM_POS_AUDIO_AM0_SUP = 0x00,
};
/*
* TYPE DEFINITIONS
****************************************************************************************
*/
/// Operation command structure in order to keep requested operation.
struct gapm_operation_cmd
{
/// GAP request type
uint8_t operation;
};
/// Command complete event data structure
struct gapm_cmp_evt
{
/// GAP requested operation
uint8_t operation;
/// Status of the request
uint8_t status;
};
/// Reset link layer and the host command
struct gapm_reset_cmd
{
/// GAPM requested operation:
/// - GAPM_RESET: Reset BLE subsystem: LL and HL.
uint8_t operation;
};
/// Set device configuration command
struct gapm_set_dev_config_cmd
{
/// GAPM requested operation:
/// - GAPM_SET_DEV_CONFIG: Set device configuration
uint8_t operation;
/// Device Role: Central, Peripheral, Observer, Broadcaster or All roles.
uint8_t role;
/// -------------- Privacy Config -----------------------
/// Duration before regenerate device address when privacy is enabled.
uint16_t renew_dur;
/// Provided own static private random address
bd_addr_t addr;
/// Device IRK used for resolvable random BD address generation (LSB first)
struct gap_sec_key irk;
/// Privacy configuration bit field (@see enum gap_priv_cfg for bit signification)
uint8_t privacy_cfg;
/// -------------- Security Config -----------------------
/// Pairing mode authorized (@see enum gapm_pairing_mode)
uint8_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
/// 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
/// +----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
/// | DBG | RFU | SC |PCP | APP_PERM | NAME_PERM |
/// +----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
/// - Bit [0-2] : Device Name write permission requirements for peer device (@see gapm_write_att_perm)
/// - Bit [3-5] : Device Appearance write permission requirements for peer device (@see gapm_write_att_perm)
/// - Bit [6] : Slave Preferred Connection Parameters present
/// - Bit [7] : Service change feature present in GATT attribute database.
/// - Bit [8-14]: Reserved
/// - Bit [15] : Enable Debug Mode
uint16_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
uint16_t sugg_max_tx_time;
/// --------------- L2CAP Configuration ---------------------------
/// Maximal MTU acceptable for device
uint16_t max_mtu;
/// Maximal MPS Packet size acceptable for device
uint16_t max_mps;
/// Maximum number of LE Credit based connection that can be established
uint8_t max_nb_lecb;
/// --------------------- Miscellaneous ---------------------------
/// API settings bit field (@see enum gap_api_settings for each bit meaning)
uint8_t api_settings;
/// --------------- LE Audio Mode Supported -----------------------
///
/// LE Audio Mode Configuration (@see gapm_audio_cfg_flag)
uint16_t audio_cfg;
/// ------------------ LE PHY Management -------------------------
/// Preferred LE PHY rate for data transmission (@see enum gap_rate)
uint8_t tx_pref_rates;
/// Preferred LE PHY rate for data reception (@see enum gap_rate)
uint8_t rx_pref_rates;
};
/// Set new IRK
struct gapm_set_irk_cmd
{
/// GAPM requested operation:
/// - GAPM_SET_IRK: Set device configuration
uint8_t operation;
/// Device IRK used for resolvable random BD address generation (LSB first)
struct gap_sec_key irk;
};
/// Set device channel map
struct gapm_set_channel_map_cmd
{
/// GAPM requested operation:
/// - GAPM_SET_CHANNEL_MAP: Set device channel map.
uint8_t operation;
/// Channel map
le_chnl_map_t chmap;
};
/// Get local device info command
struct gapm_get_dev_info_cmd
{
/// GAPM requested operation:
/// - GAPM_GET_DEV_VERSION: Get Local device version
/// - GAPM_GET_DEV_BDADDR: Get Local device BD Address
/// - GAPM_GET_DEV_ADV_TX_POWER: Get device advertising power level
/// - GAPM_DBG_GET_MEM_INFO: Get memory usage (debug only)
uint8_t operation;
};
/// Local device version indication event
struct gapm_dev_version_ind
{
/// HCI version
uint8_t hci_ver;
/// LMP version
uint8_t lmp_ver;
/// Host version
uint8_t host_ver;
/// HCI revision
uint16_t hci_subver;
/// LMP subversion
uint16_t lmp_subver;
/// Host revision
uint16_t host_subver;
/// Manufacturer name
uint16_t manuf_name;
};
/// Local device BD Address indication event
struct gapm_dev_bdaddr_ind
{
/// Local device address information
struct gap_bdaddr addr;
};
/// Advertising channel Tx power level indication event
struct gapm_dev_adv_tx_power_ind
{
/// Advertising channel Tx power level
int8_t power_lvl;
};
/// Cancel ongoing operation - DEPRECATED
struct gapm_cancel_cmd
{
/// GAPM requested operation
/// - GAPM_CANCEL: Cancel running operation
uint8_t operation;
};
/// White List Management Command - DEPRECATED
struct gapm_white_list_mgt_cmd
{
/// GAPM requested operation:
/// - GAPM_GET_WLIST_SIZE: Get White List Size.
/// - GAPM_ADD_DEV_IN_WLIST: Add devices in white list.
/// - GAPM_RMV_DEV_FRM_WLIST: Remove devices form white list.
/// - GAPM_CLEAR_WLIST: Clear all devices from white list.
uint8_t operation;
/// Number of device information present in command
uint8_t nb;
/// Device address information that can be used to add or remove element in device list.
struct gap_bdaddr devices[__ARRAY_EMPTY];
};
/// Resolving List Management Command - DEPRECATED
struct gapm_ral_mgt_cmd
{
/// GAPM requested operation:
/// - GAPM_GET_RAL_SIZE: Get Resolving List Size.
/// - GAPM_GET_RAL_LOC_ADDR: Get Resolving Local Address.
/// - GAPM_GET_RAL_PEER_ADDR: Get Resolving Peer Address.
/// - GAPM_ADD_DEV_IN_RAL: Add devices in resolving list.
/// - GAPM_RMV_DEV_FRM_RAL: Remove devices form resolving list.
/// - GAPM_CLEAR_RAL: Clear all devices from resolving list.
uint8_t operation;
/// Number of device information present in command
uint8_t nb;
/// Device address information that can be used to add or remove element in device list.
struct gap_ral_dev_info devices[__ARRAY_EMPTY];
};
/// Resolving Address indication event
struct gapm_ral_addr_ind
{
/// Peer or local read operation
uint8_t operation;
/// Resolving List address
struct gap_bdaddr addr;
};
/// Resolve Address command
struct gapm_resolv_addr_cmd
{
/// GAPM requested operation:
/// - GAPM_RESOLV_ADDR: Resolve device address
uint8_t operation;
/// Number of provided IRK (sahlle be > 0)
uint8_t nb_key;
/// Resolvable random address to solve
bd_addr_t addr;
/// Array of IRK used for address resolution (MSB -> LSB)
struct gap_sec_key irk[__ARRAY_EMPTY];
};
/// Indicate that resolvable random address has been solved
struct gapm_addr_solved_ind
{
/// Resolvable random address solved
bd_addr_t addr;
/// IRK that correctly solved the random address
struct gap_sec_key irk;
};
/// Advertising data that contains information set by host. - DEPRECATED
struct gapm_adv_host
{
/// Advertising mode :
/// - GAP_NON_DISCOVERABLE: Non discoverable mode
/// - GAP_GEN_DISCOVERABLE: General discoverable mode
/// - GAP_LIM_DISCOVERABLE: Limited discoverable mode
/// - GAP_BROADCASTER_MODE: Broadcaster mode
uint8_t mode;
/// Advertising filter policy:
/// - ADV_ALLOW_SCAN_ANY_CON_ANY: Allow both scan and connection requests from anyone
/// - ADV_ALLOW_SCAN_WLST_CON_ANY: Allow both scan req from White List devices only and
/// connection req from anyone
/// - ADV_ALLOW_SCAN_ANY_CON_WLST: Allow both scan req from anyone and connection req
/// from White List devices only
/// - ADV_ALLOW_SCAN_WLST_CON_WLST: Allow scan and connection requests from White List
/// devices only
uint8_t adv_filt_policy;
/// Advertising data length - maximum 28 bytes, 3 bytes are reserved to set
/// Advertising AD type flags, shall not be set in advertising data
uint8_t adv_data_len;
/// Advertising data
uint8_t adv_data[GAP_ADV_DATA_LEN];
/// Scan response data length- maximum 31 bytes
uint8_t scan_rsp_data_len;
/// Scan response data
uint8_t scan_rsp_data[GAP_SCAN_RSP_DATA_LEN];
/// Peer address
struct gap_bdaddr peer_addr;
uint8_t flags;
};
/// Air operation default parameters - DEPRECATED
struct gapm_air_operation
{
/// Operation code.
uint8_t code;
/**
* Own BD address source of the device:
* - GAPM_STATIC_ADDR: Public or Private Static Address according to device address configuration
* - GAPM_GEN_RSLV_ADDR: Generated resolvable private random address
* - GAPM_GEN_NON_RSLV_ADDR: Generated non-resolvable private random address
*/
uint8_t addr_src;
/// Dummy data use to retrieve internal operation state (should be set to 0).
uint16_t state;
uint16_t randomAddrRenewIntervalInSecond;
};
/// Set advertising mode Command - DEPRECATED
struct gapm_start_advertise_cmd
{
/// GAPM requested operation:
/// - GAPM_ADV_NON_CONN: Start non connectable advertising
/// - GAPM_ADV_UNDIRECT: Start undirected connectable advertising
/// - GAPM_ADV_DIRECT: Start directed connectable advertising
/// - GAPM_ADV_DIRECT_LDC: Start directed connectable advertising using Low Duty Cycle
struct gapm_air_operation op;
/// Minimum interval for advertising
uint16_t intv_min;
/// Maximum interval for advertising
uint16_t intv_max;
///Advertising channel map
uint8_t channel_map;
//true:force reserve 3 byte for ourself;false:all 31 byte can use by customer,default open this flag,reserve 3byte
uint8_t isIncludedFlags;
/// Advertising information
union gapm_adv_info
{
/// Host information advertising data (GAPM_ADV_NON_CONN and GAPM_ADV_UNDIRECT)
struct gapm_adv_host host;
/// Direct address information (GAPM_ADV_DIRECT)
/// (used only if reconnection address isn't set or privacy disabled)
struct gap_bdaddr direct;
} info;
};
/// Update Advertising Data Command - On fly update when device is advertising - DEPRECATED
struct gapm_update_advertise_data_cmd
{
/// GAPM requested operation:
/// - GAPM_UPDATE_ADVERTISE_DATA: Update on the fly advertising data
uint8_t operation;
/// Advertising data length - maximum 28 bytes, 3 bytes are reserved to set
/// Advertising AD type flags, shall not be set in advertising data
uint8_t adv_data_len;
/// Advertising data
uint8_t adv_data[GAP_ADV_DATA_LEN];
/// Scan response data length- maximum 31 bytes
uint8_t scan_rsp_data_len;
/// Scan response data
uint8_t scan_rsp_data[GAP_SCAN_RSP_DATA_LEN];
};
/// Set scan mode Command - DEPRECATED
struct gapm_start_scan_cmd
{
/// GAPM requested operation:
/// - GAPM_SCAN_ACTIVE: Start active scan operation
/// - GAPM_SCAN_PASSIVE: Start passive scan operation
struct gapm_air_operation op;
/// Scan interval
uint16_t interval;
/// Scan window size
uint16_t window;
/// Scanning mode :
/// - GAP_GEN_DISCOVERY: General discovery mode
/// - GAP_LIM_DISCOVERY: Limited discovery mode
/// - GAP_OBSERVER_MODE: Observer mode
uint8_t mode;
/// Scan filter policy:
/// - SCAN_ALLOW_ADV_ALL: Allow advertising packets from anyone
/// - SCAN_ALLOW_ADV_WLST: Allow advertising packets from White List devices only
uint8_t filt_policy;
/// Scan duplicate filtering policy:
/// - SCAN_FILT_DUPLIC_DIS: Disable filtering of duplicate packets
/// - SCAN_FILT_DUPLIC_EN: Enable filtering of duplicate packets
uint8_t filter_duplic;
};
/// Advertising or scanning report information event - DEPRECATED
struct gapm_adv_report_ind
{
/// Advertising report structure
adv_report_t report;
};
/// Set connection initialization Command - DEPRECATED
struct gapm_start_connection_cmd
{
/// GAPM requested operation:
/// - GAPM_CONNECTION_DIRECT: Direct connection operation
/// - GAPM_CONNECTION_AUTO: Automatic connection operation
/// - GAPM_CONNECTION_SELECTIVE: Selective connection operation
/// - GAPM_CONNECTION_NAME_REQUEST: Name Request operation (requires to start a direct
/// connection)
/// - GAPM_CONNECTION_GENERAL: General connection operation
struct gapm_air_operation op;
/// Scan interval
uint16_t scan_interval;
/// Scan window size
uint16_t scan_window;
/// Minimum of connection interval
uint16_t con_intv_min;
/// Maximum of connection interval
uint16_t con_intv_max;
/// Connection latency
uint16_t con_latency;
/// Link supervision timeout
uint16_t superv_to;
/// Minimum CE length
uint16_t ce_len_min;
/// Maximum CE length
uint16_t ce_len_max;
/// Number of peer device information present in message.
/// Shall be 1 for GAPM_CONNECTION_DIRECT or GAPM_CONNECTION_NAME_REQUEST operations
/// Shall be greater than 0 for other operations
uint8_t nb_peers;
/// Peer device information
struct gap_bdaddr peers[__ARRAY_EMPTY];
};
/// Confirm connection to a specific device (Connection Operation in Selective mode) - DEPRECATED
struct gapm_connection_cfm
{
/// peer device bd address
bd_addr_t addr;
/// peer device address type
uint8_t addr_type;
/// Minimum of connection interval
uint16_t con_intv_min;
/// Maximum of connection interval
uint16_t con_intv_max;
/// Connection latency
uint16_t con_latency;
/// Link supervision timeout
uint16_t superv_to;
/// Minimum CE length
uint16_t ce_len_min;
/// Maximum CE length
uint16_t ce_len_max;
};
/// Name of peer device indication
struct gapm_peer_name_ind
{
/// peer device bd address
bd_addr_t addr;
/// peer device address type
uint8_t addr_type;
/// peer device name length
uint8_t name_len;
/// peer device name
uint8_t name[__ARRAY_EMPTY];
};
/// Generate a random address.
struct gapm_gen_rand_addr_cmd
{
/// GAPM requested operation:
/// - GAPM_GEN_RAND_ADDR: Generate a random address
uint8_t operation;
/// Dummy parameter used to store the prand part of the address
uint8_t prand[GAP_ADDR_PRAND_LEN];
/// Random address type @see gap_rnd_addr_type
/// - GAP_STATIC_ADDR: Static random address
/// - GAP_NON_RSLV_ADDR: Private non resolvable address
/// - GAP_RSLV_ADDR: Private resolvable address
uint8_t rnd_type;
};
/// Parameters of the @ref GAPM_USE_ENC_BLOCK_CMD message
struct gapm_use_enc_block_cmd
{
/// Command Operation Code (shall be GAPM_USE_ENC_BLOCK)
uint8_t operation;
/// Operand 1
uint8_t operand_1[GAP_KEY_LEN];
/// Operand 2
uint8_t operand_2[GAP_KEY_LEN];
};
/// Parameters of the @ref GAPM_USE_ENC_BLOCK_IND message
struct gapm_use_enc_block_ind
{
/// Result (16 bytes)
uint8_t result[GAP_KEY_LEN];
};
/// Parameters of the @ref GAPM_GEN_DH_KEY_CMD message
struct gapm_gen_dh_key_cmd
{
/// Command Operation Code (shall be GAPM_GEN_DH_KEY)
uint8_t operation;
/// X coordinate
uint8_t operand_1[GAP_P256_KEY_LEN];
/// Y coordinate
uint8_t operand_2[GAP_P256_KEY_LEN];
};
/// Parameters of the @ref GAPM_GEN_DH_KEY_IND message
struct gapm_gen_dh_key_ind
{
/// Result (32 bytes)
uint8_t result[GAP_P256_KEY_LEN];
};
/// Parameters of the @ref GAPM_GEN_RAND_NB_CMD message
struct gapm_gen_rand_nb_cmd
{
/// Command Operation Code (shall be GAPM_GEN_RAND_NB)
uint8_t operation;
};
/// Parameters of the @ref GAPM_GEN_RAND_NB_IND message
struct gapm_gen_rand_nb_ind
{
/// Generation Random Number (8 bytes)
rand_nb_t randnb;
};
/// Create new task for specific profile
struct gapm_profile_task_add_cmd
{
/// GAPM requested operation:
/// - GAPM_PROFILE_TASK_ADD: Add new profile task
uint8_t operation;
/// Security Level :
/// 7 6 5 4 3 2 1 0
/// +----+----+----+----+----+----+----+----+
/// | Reserved |DIS | AUTH |EKS | MI |
/// +----+----+----+----+----+----+----+----+
///
/// - MI: 1 - Application task is a Multi-Instantiated task, 0 - Mono-Instantiated
/// Only applies for service - Ignored by collectors:
/// - EKS: Service needs a 16 bytes encryption key
/// - AUTH: 0 - Disable, 1 - Enable, 2 - Unauth, 3 - Auth
/// - DIS: Disable the service
uint8_t sec_lvl;
/// Profile task identifier
uint16_t prf_task_id;
/// Application task number
uint16_t app_task;
/// Service start handle
/// Only applies for services - Ignored by collectors
/// 0: dynamically allocated in Attribute database
uint16_t start_hdl;
/// 32 bits value that contains value to initialize profile (database parameters, etc...)
uint32_t param[__ARRAY_EMPTY];
};
/// Inform that profile task has been added.
struct gapm_profile_added_ind
{
/// Profile task identifier
uint16_t prf_task_id;
/// Profile task number allocated
uint16_t prf_task_nb;
/// Service start handle
/// Only applies for services - Ignored by collectors
uint16_t start_hdl;
};
/// Indicate that a message has been received on an unknown task
struct gapm_unknown_task_ind
{
/// Message identifier
uint16_t msg_id;
/// Task identifier
uint16_t task_id;
};
/// Indicates suggested default data length
struct gapm_sugg_dflt_data_len_ind
{
///Host's suggested value for the Controller's maximum transmitted number of payload octets
uint16_t suggted_max_tx_octets;
///Host's suggested value for the Controller's maximum packet transmission time
uint16_t suggted_max_tx_time;
};
/// Indicates maximum data length
struct gapm_max_data_len_ind
{
///Maximum number of payload octets that the local Controller supports for transmission
uint16_t suppted_max_tx_octets;
///Maximum time, in microseconds, that the local Controller supports for transmission
uint16_t suppted_max_tx_time;
///Maximum number of payload octets that the local Controller supports for reception
uint16_t suppted_max_rx_octets;
///Maximum time, in microseconds, that the local Controller supports for reception
uint16_t suppted_max_rx_time;
};
/// Register a LE Protocol/Service Multiplexer command
struct gapm_lepsm_register_cmd
{
/// GAPM requested operation:
/// - GAPM_LEPSM_REG: Register a LE Protocol/Service Multiplexer
uint8_t operation;
/// LE Protocol/Service Multiplexer
uint16_t le_psm;
/// Application task number
uint16_t app_task;
/// Security level
/// 7 6 5 4 3 2 1 0
/// +---+---+---+---+---+---+---+---+
/// |MI | RFU |EKS|SEC_LVL|
/// +---+---+---+---+---+---+---+---+
/// bit[0-1]: Security level requirement (0=NO_AUTH, 1=UNAUTH, 2=AUTH, 3=SEC_CON)
/// bit[2] : Encryption Key Size length must have 16 bytes
/// bit[7] : Does the application task is multi-instantiated or not
uint8_t sec_lvl;
};
/// Unregister a LE Protocol/Service Multiplexer command
struct gapm_lepsm_unregister_cmd
{
/// GAPM requested operation:
/// - GAPM_LEPSM_UNREG: Unregister a LE Protocol/Service Multiplexer
uint8_t operation;
/// LE Protocol/Service Multiplexer
uint16_t le_psm;
};
/// Create an advertising, a scanning, an initiating, a periodic synchonization activity command (common)
struct gapm_activity_create_cmd
{
/// GAPM request operation:
/// - GAPM_CREATE_ADV_ACTIVITY: Create advertising activity
/// - GAPM_CREATE_SCAN_ACTIVITY: Create scanning activity
/// - GAPM_CREATE_INIT_ACTIVITY: Create initiating activity
/// - GAPM_CREATE_PERIOD_SYNC_ACTIVITY: Create periodic synchronization activity
uint8_t operation;
/// Own address type
uint8_t own_addr_type;
};
/// Create an advertising activity command
struct gapm_activity_create_adv_cmd
{
/// GAPM request operation:
/// - GAPM_CREATE_ADV_ACTIVITY: Create advertising activity
uint8_t operation;
/// Own address type (@see gap_own_addr_type)
uint8_t own_addr_type;
/// Advertising parameters (optional, shall be present only if operation is GAPM_CREATE_ADV_ACTIVITY)
struct gap_adv_param adv_param;
};
/// Start a given activity command
struct gapm_activity_start_cmd
{
/// GAPM request operation:
/// - GAPM_START_ACTIVITY: Start a given activity
uint8_t operation;
/// Activity identifier
uint8_t actv_idx;
/// Activity parameters
union
{
/// Additional advertising parameters (for advertising activity)
struct gap_adv_add_param adv_add_param;
/// Scan parameters (for scanning activity)
struct gap_scan_param scan_param;
/// Initiating parameters (for initiating activity)
struct gap_init_param init_param;
/// Periodic synchronization parameters (for periodic synchronization activity)
struct gap_period_sync_param period_sync_param;
} u_param;
};
/// Stop one or all activity(ies) command
struct gapm_activity_stop_cmd
{
/// GAPM request operation:
/// - GAPM_STOP_ACTIVITY: Stop a given activity
/// - GAPM_STOP_ALL_ACTIVITIES: Stop all existing activities
uint8_t operation;
/// Activity identifier - used only if operation is GAPM_STOP_ACTIVITY
uint8_t actv_idx;
};
/// Delete one or all activity(ies) command
struct gapm_activity_delete_cmd
{
/// GAPM request operation:
/// - GAPM_DELETE_ACTIVITY: Delete a given activity
/// - GAPM_DELETE_ALL_ACTIVITIES: Delete all existing activities
uint8_t operation;
/// Activity identifier - used only if operation is GAPM_STOP_ACTIVITY
uint8_t actv_idx;
};
/// Indicate creation of an activity
struct gapm_activity_created_ind
{
/// Activity identifier
uint8_t actv_idx;
/// Activity type (@see enum gap_actv_type)
uint8_t actv_type;
/// Selected TX power for advertising activity
int8_t tx_pwr;
};
/// Indicate that an activity has been stopped
struct gapm_activity_stopped_ind
{
/// Activity identifier
uint8_t actv_idx;
/// Activity type (@see enum gap_actv_type)
uint8_t actv_type;
/// Activity stop reason
uint8_t reason;
/// In case of periodic advertising, indicate if periodic advertising has been stoppped
uint8_t per_adv_stop;
};
/// Set advertising, scan response or periodic advertising data command
struct gapm_set_adv_data_cmd
{
/// GAPM request operation:
/// - GAPM_SET_ADV_DATA: Set advertising data
/// - GAPM_SET_SCAN_RSP_DATA: Set scan response data
/// - GAPM_SET_PERIOD_ADV_DATA: Set periodic advertising data
uint8_t operation;
/// Activity identifier
uint8_t actv_idx;
/// Data length
uint16_t length;
/// Data
uint8_t data[__ARRAY_EMPTY];
};
/// Indicate reception of scan request
struct gapm_scan_request_ind
{
/// Activity identifier
uint8_t actv_idx;
/// Transmitter device address
struct gap_bdaddr trans_addr;
};
/// Indicate reception of advertising, scan response or periodic advertising data
struct gapm_ext_adv_report_ind
{
/// Activity identifier
uint8_t actv_idx;
/// Bit field providing information about the received report (@see enum gap_adv_report_info)
/// - Bit 0-2: Report type (@see enum gap_adv_report_type)
/// - Bit 3: Report is complete
/// - Bit 4: Connectable advertising
/// - Bit 5: Scannable advertising
/// - Bit 6: Directed advertising
/// - Bit 7: Reserved for future use
uint8_t info;
/// Transmitter device address
struct gap_bdaddr trans_addr;
/// Target address (in case of a directed advertising report)
struct gap_bdaddr target_addr;
/// TX power (in dBm)
int8_t tx_pwr;
/// RSSI (between -127 and +20 dBm)
int8_t rssi;
/// Primary PHY on which advertising report has been received
uint8_t phy_prim;
/// Secondary PHY on which advertising report has been received
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];
};
/// Indicate that synchronization has been established with a periodic advertiser
struct gapm_sync_established_ind
{
/// Activity identifier
uint8_t actv_idx;
/// PHY on which synchronization has been established (@see gap_phy_type)
uint8_t phy;
/// Periodic advertising interval (in unit of 1.25ms, min is 7.5ms)
uint16_t intv;
/// Advertising SID
uint8_t adv_sid;
/// Advertiser clock accuracy (@see enum gap_clock_accuracy)
uint8_t clk_acc;
/// Advertiser address
struct gap_bdaddr addr;
};
/// Read local or peer address
struct gapm_get_ral_addr_cmd
{
/// GAPM request operation:
/// - GAPM_GET_RAL_LOC_ADDR: Set white list content
/// - GAPM_GET_RAL_PEER_ADDR: Set resolving list content
uint8_t operation;
/// Peer device identity
struct gap_bdaddr peer_identity;
};
/// Set content of either white list or resolving list or periodic advertiser list command (common part)
struct gapm_list_set_cmd
{
/// GAPM request operation:
/// - GAPM_SET_WHITE_LIST: Set white list content
/// - GAPM_SET_RAL: Set resolving list content
/// - GAPM_SET_PAL: Set periodic advertiser list content
uint8_t operation;
/// Number of entries to be added in the list. 0 means that list content has to be cleared
uint8_t size;
};
/// Set content of white list
struct gapm_list_set_wl_cmd
{
/// GAPM request operation:
/// - GAPM_SET_WHITE_LIST: Set white list content
uint8_t operation;
/// Number of entries to be added in the list. 0 means that list content has to be cleared
uint8_t size;
/// List of entries to be added in the list
struct gap_bdaddr wl_info[__ARRAY_EMPTY];
};
/// Set content of resolving list command
struct gapm_list_set_ral_cmd
{
/// GAPM request operation:
/// - GAPM_SET_RAL: Set resolving list content
uint8_t operation;
/// Number of entries to be added in the list. 0 means that list content has to be cleared
uint8_t size;
/// List of entries to be added in the list
struct gap_ral_dev_info ral_info[__ARRAY_EMPTY];
};
/// Set content of periodic advertiser list command
struct gapm_list_set_pal_cmd
{
/// GAPM request operation:
/// - GAPM_SET_PAL: Set periodic advertiser list content
uint8_t operation;
/// Number of entries to be added in the list. 0 means that list content has to be cleared
uint8_t size;
/// List of entries to be added in the list
struct gap_period_adv_addr_cfg pal_info[__ARRAY_EMPTY];
};
/// White List Size indication event - DEPRECATED
struct gapm_white_list_size_ind
{
/// White list size
uint8_t size;
};
/// Resolving List Size indication event - DEPRECATED
struct gapm_ral_size_ind
{
/// Resolving list size
uint8_t size;
};
/// List Size indication event
struct gapm_list_size_ind
{
/// Operation code, indicate list for which size has been read
uint8_t operation;
/// List size
uint8_t size;
};
/// Maximum advertising data length indication event
struct gapm_max_adv_data_len_ind
{
/// Maximum advertising data length supported by controller
uint16_t length;
};
/// Number of available advertising sets indication event
struct gapm_nb_adv_sets_ind
{
/// Number of available advertising sets
uint8_t nb_adv_sets;
};
/// Request to renew all currently used random private addresses (non-resolvable or resolvable)
/// For internal use only
struct gapm_actv_addr_renew_cmd
{
/// GAPM request operation:
/// - GAPM_RENEW_ADDR: Renew random private addresses
uint8_t operation;
/// Activity index, sued by GAPM state machine in order to remind for which activity
/// a new address has been generated
uint8_t actv_idx;
};
/*
* MACROS
****************************************************************************************
*/
/*
* GLOBAL VARIABLE DECLARATIONS
****************************************************************************************
*/
/*
* FUNCTION DECLARATIONS
****************************************************************************************
*/
int hci_no_operation_cmd_cmp_evt_handler(uint16_t opcode, void const *param);
/// @} GAPM_TASK
#endif /* _GAPM_TASK_H_ */