/* **************************************************************************************** * * @file gap_api.h * @version v1.0 * @brief GAP API exposed to app layer * @attention * Copyright (C) 2022 Freqchip. \n * All rights reserved. \n * * **************************************************************************************** */ #ifndef _GAP_API_H #define _GAP_API_H #ifdef __cplusplus extern "C" { #endif /* Includes ------------------------------------------------------------------*/ #include #include #include "gap_defines.h" #include "ble_api_error.h" /* Exported types ------------------------------------------------------------*/ enum gap_event_type { GAP_EVT_ADV_SET_PARAM, //!< Set advertising parameter ended GAP_EVT_ADV_SET_ADV_DATA, //!< Set advertising data ended GAP_EVT_ADV_SET_SCAN_RSP, //!< Set advertising scan response data ended GAP_EVT_ADV_SET_PER_DATA, //!< Set periodic advertising data ended GAP_EVT_ADV_START, GAP_EVT_ADV_END, //!< Advertising ended GAP_EVT_SCAN_START, GAP_EVT_SCAN_END, //!< Scanning ended GAP_EVT_ADV_REPORT, //!< Scan result report GAP_EVT_CONN_START, GAP_EVT_CONN_END, //!< Connecion action is ended GAP_EVT_NAME_REQ, //!< Name request from peer device through GAP GAP_EVT_SLAVE_PREF_PARAM, //!< Slave prefer parameter from peer device through GAP GAP_EVT_APPEARANCE_REQ, //!< Appearance request from peer device through GAP GAP_EVT_SLAVE_CONNECT, //!< Connected as slave role GAP_EVT_MASTER_CONNECT, //!< Connected as master role GAP_EVT_DISCONNECT, //!< Connection is removed GAP_EVT_LINK_PARAM_REQ, //!< Parameter update request GAP_EVT_LINK_PARAM_REJECT, //!< Parameter update rejected GAP_EVT_LINK_PARAM_UPDATE, //!< Parameter update successful GAP_EVT_SMP_TK_REQ, //!< reqeust Temporary Key in pairing procedure GAP_EVT_SMP_NC_REQ, //!< Send Numbric Comparision to app layer GAP_EVT_SMP_BOND_SUCCESS, //!< Link bond is successful GAP_EVT_SMP_BOND_FAILED, //!< Link bond is failed GAP_EVT_SMP_ENCRYPT_SUCCESS, //!< Link encrypt successful GAP_EVT_SMP_ENCRYPT_FAILED, //!< Link encrypt failed GAP_EVT_SMP_SEC_REQ, //!< Recvive security request from slave GAP_EVT_SMP_PAIR_REQ, //!< Recvive pair request from master, need to call GAP_EVT_SMP_ENCRYPT_REQ, //!< Recvive encrypt request from master GATT_EVT_MTU, //!< Mtu updated GAP_EVT_PHY_REJECT, //!< Parameter update rejected GAP_EVT_PHY_IND, //!< PHY update indication or read phy success GAP_EVT_LINK_FEATURE, //!< Got peer device supported features GAP_EVT_LINK_RSSI, //!< Got RSSI value of link peer device GAP_EVT_LINK_VER, //!< Got version value of link peer device GAP_EVT_ADD_DEVICE_TO_WL, //!< Result of add device to white list GAP_EVT_RMV_DEVICE_FROM_WL, //!< Result pf remove device from white list GAP_EVT_ADD_DEVICE_TO_RAL, //!< Result of add device to resolve list GATT_EVT_PROFILE_ADDED, //!< GATT profile have been added }; enum gap_adv_state { GAP_ADV_STATE_NONE, //!< Advertising not created. GAP_ADV_STATE_IDLE, //!< Successfully setting advertising parameters or stopping advertising will be in this state. GAP_ADV_STATE_CREATING, //!< After calling gap_adv_set_param() and before reporting the GAP_EVT_ADV_SET_PARAM event, will be in this state. GAP_ADV_STATE_STARTING, //!< After calling gap_adv_start() and before reporting the GAP_EVT_ADV_START event, will be in this state. GAP_ADV_STATE_WORKING, //!< After reporting the GAP_EVT_ADV_START event and status is 0x00, will be in this state. GAP_ADV_STATE_STOPPING, //!< After calling gap_adv_stop() and before reporting the GAP_EVT_ADV_STOP event, will be in this state. GAP_ADV_STATE_DELETING, }; enum gap_own_addr_type { GAP_ADDR_TYPE_STATIC, //!< Public or Private Static Address according to device address configuration GAP_ADDR_TYPE_GEN_RSLV, //!< Generated resolvable private random address GAP_ADDR_TYPE_GEN_NON_RSLV, //!< Generated non-resolvable private random address }; enum gap_adv_mode { GAP_ADV_MODE_UNDIRECT = 0x01, GAP_ADV_MODE_DIRECT = 0x02, GAP_ADV_MODE_NON_CONN_NON_SCAN = 0x03, GAP_ADV_MODE_NON_CONN_SCAN = 0x04, GAP_ADV_MODE_HDC_DIRECT = 0x05, GAP_ADV_MODE_BEACON = 0x06, GAP_ADV_MODE_EXTEND_CONN_UNDIRECT = 0x11, GAP_ADV_MODE_EXTEND_CONN_DIRECT = 0x12, GAP_ADV_MODE_EXTEND_NON_CONN_SCAN = 0x13, GAP_ADV_MODE_EXTEND_NON_CONN_SCAN_DIRECT = 0x14, GAP_ADV_MODE_EXTEND_NON_CONN_NON_SCAN = 0x15, GAP_ADV_MODE_EXTEND_NON_CONN_NON_SCAN_DIRECT = 0x16, GAP_ADV_MODE_PER_ADV_UNDIRECT = 0x21, GAP_ADV_MODE_PER_ADV_DIRECT = 0x22, }; enum gap_adv_chan { GAP_ADV_CHAN_37 = 0x01, GAP_ADV_CHAN_38 = 0x02, GAP_ADV_CHAN_39 = 0x04, GAP_ADV_CHAN_ALL = 0x07, }; enum gap_adv_filter { GAP_ADV_FILTER_SCAN_ANY_CON_ANY = 0x00, //!< The Link Layer shall process scan and connection requests from all devices. GAP_ADV_FILTER_SCAN_WLST_CON_ANY = 0x01, //!< The Link Layer shall process connection requests from all devices, //!< and shall only process scan requests from devices that are in the White List. GAP_ADV_FILTER_SCAN_ANY_CON_WLST = 0x02, //!< The Link Layer shall process scan requests from all devices, //!< and shall only process connection requests from devices that are in the White List. GAP_ADV_FILTER_SCAN_WLST_CON_WLST = 0x03, //!< The Link Layer shall process scan and connection requests only from //!< devices in the White List }; enum gap_adv_disc_mode { GAP_ADV_DISC_MODE_NON_DISC = 0, //!< Non-Discoverable mode //!< This mode of package will be filtered out in the host layer. GAP_ADV_DISC_MODE_GEN_DISC = 1, //!< General Discoverable mopde //!< Except for scan mode GAP_SCAN_TYPE_GEN_DISC, //!< other scan modes will filter out this mode of package at the host layer GAP_ADV_DISC_MODE_LIM_DISC = 2, //!< Limited Discoverable mopde //!< This mode of package will automatically stop within a certain period of time //!< Can be received by devices using GAP_SCAN_TYPE_GEN_DISC and GAP_SCAN_TYPE_LIM_DISC scanning modes GAP_ADV_DISC_MODE_BEACON = 3, }; enum gap_scan_type { GAP_SCAN_TYPE_GEN_DISC = 0, //!< General discovery, active scanning GAP_SCAN_TYPE_LIM_DISC = 1, //!< Limited discovery, active scanning GAP_SCAN_TYPE_OBSERVER = 2, //!< Observer, passive scanning GAP_SCAN_TYPE_SEL_OBSERVER = 3, //!< Selective observer, passive scanning, only receive advertising data from whitelist GAP_SCAN_TYPE_CONN_DISC = 4, //!< Connectable discovery GAP_SCAN_TYPE_SEL_CONN_DISC = 5, //!< Selective connectable discovery }; enum gap_phy_type { /// LE 1M GAP_PHY_TYPE_LE_1M = (1<<0), /// LE 2M GAP_PHY_TYPE_LE_2M = (1<<1), /// LE Coded GAP_PHY_TYPE_LE_CODED = (1<<2), }; enum smp_tk_type { GAP_TK_TYPE_OOB, GAP_TK_TYPE_DISPLAY, //!< Display TK(pin code) GAP_TK_TYPE_ENTRY, //!< Input TK(pin code) }; enum gap_sec_mode { ENABLE_AUTO_RSP, //!< Automatically reply to pairing or encryption requests DISABLE_AUTO_RSP, //!< Pairing or encryption requests will be reported to the GAP callback function //!< The user will decide whether to reply or not //!< Callback event is either GAP_EVT_SMP_PAIR_REQ or GAP_EVT_SMP_ENCRYPT_REQ }; enum local_device_con_role { LOCAL_ROLE_MASTER = 0, LOCAL_ROLE_SLAVE, LOCAL_ROLE_NONE, }; enum adv_type_flag{ AUTO_ADV_TYPE_FLAG, USER_SET_ADV_TYPE_FLAG, }; /** @defgroup GAP_ADVTYPE_DEFINES GAP Advertisement Data Types * These are the data type identifiers for the data tokens in the advertisement data field. * @{ */ #define GAP_ADTVYPE_FLAGS 0x01 //!< Discovery Mode: @ref GAP_ADTYPE_FLAGS_MODES #define GAP_ADVTYPE_16BIT_MORE 0x02 //!< Service: More 16-bit UUIDs available #define GAP_ADVTYPE_16BIT_COMPLETE 0x03 //!< Service: Complete list of 16-bit UUIDs #define GAP_ADVTYPE_32BIT_MORE 0x04 //!< Service: More 32-bit UUIDs available #define GAP_ADVTYPE_32BIT_COMPLETE 0x05 //!< Service: Complete list of 32-bit UUIDs #define GAP_ADVTYPE_128BIT_MORE 0x06 //!< Service: More 128-bit UUIDs available #define GAP_ADVTYPE_128BIT_COMPLETE 0x07 //!< Service: Complete list of 128-bit UUIDs #define GAP_ADVTYPE_LOCAL_NAME_SHORT 0x08 //!< Shortened local name #define GAP_ADVTYPE_LOCAL_NAME_COMPLETE 0x09 //!< Complete local name #define GAP_ADVTYPE_POWER_LEVEL 0x0A //!< TX Power Level: 0xXX: -127 to +127 dBm #define GAP_ADVTYPE_OOB_CLASS_OF_DEVICE 0x0D //!< Simple Pairing OOB Tag: Class of device (3 octets) #define GAP_ADVTYPE_OOB_SIMPLE_PAIRING_HASHC 0x0E //!< Simple Pairing OOB Tag: Simple Pairing Hash C (16 octets) #define GAP_ADVTYPE_OOB_SIMPLE_PAIRING_RANDR 0x0F //!< Simple Pairing OOB Tag: Simple Pairing Randomizer R (16 octets) #define GAP_ADVTYPE_SM_TK 0x10 //!< Security Manager TK Value #define GAP_ADVTYPE_SM_OOB_FLAG 0x11 //!< Secutiry Manager OOB Flags #define GAP_ADVTYPE_SLAVE_CONN_INTERVAL_RANGE 0x12 //!< Min and Max values of the connection interval (2 octets Min, 2 octets Max) (0xFFFF indicates no conn interval min or max) #define GAP_ADVTYPE_SIGNED_DATA 0x13 //!< Signed Data field #define GAP_ADVTYPE_SERVICES_LIST_16BIT 0x14 //!< Service Solicitation: list of 16-bit Service UUIDs #define GAP_ADVTYPE_SERVICES_LIST_128BIT 0x15 //!< Service Solicitation: list of 128-bit Service UUIDs #define GAP_ADVTYPE_SERVICE_DATA 0x16 //!< Service Data - 16-bit UUID #define GAP_ADVTYPE_PUBLIC_TARGET_ADDR 0x17 //!< Public Target Address #define GAP_ADVTYPE_RANDOM_TARGET_ADDR 0x18 //!< Random Target Address #define GAP_ADVTYPE_APPEARANCE 0x19 //!< Appearance #define GAP_ADVTYPE_ADV_INTERVAL 0x1A //!< Advertising Interval #define GAP_ADVTYPE_LE_BD_ADDR 0x1B //!< LE Bluetooth Device Address #define GAP_ADVTYPE_LE_ROLE 0x1C //!< LE Role #define GAP_ADVTYPE_SIMPLE_PAIRING_HASHC_256 0x1D //!< Simple Pairing Hash C-256 #define GAP_ADVTYPE_SIMPLE_PAIRING_RANDR_256 0x1E //!< Simple Pairing Randomizer R-256 #define GAP_ADVTYPE_SERVICE_DATA_32BIT 0x20 //!< Service Data - 32-bit UUID #define GAP_ADVTYPE_SERVICE_DATA_128BIT 0x21 //!< Service Data - 128-bit UUID #define GAP_ADVTYPE_3D_INFO_DATA 0x3D //!< 3D Information Data #define GAP_ADVTYPE_MANUFACTURER_SPECIFIC 0xFF //!< Manufacturer Specific Data: first 2 octets contain the Company Identifier Code followed by the additional manufacturer specific data /** @} End GAP_ADVTYPE_DEFINES */ /** @defgroup GAP_SCAN_EVT_TYPE_DEFINES GAP Event Types * @{ */ #define GAP_SCAN_EVT_CONN_UNDIR 0x00 //!< Undirected advertising #define GAP_SCAN_EVT_CONN_DIR 0x01 //!< Directed advertising #define GAP_SCAN_EVT_NONCONN_UNDIR 0x02 //!< Non Connectable advertising #define GAP_SCAN_EVT_SCAN_RSP 0x04 //!< Scan Response #define GAP_SCAN_EVT_NONCONN_NONSCAN 0x08 //!< Non Connectable Non Scan advertising #define GAP_SCAN_EVT_EXT_ADV 0x10 //!< Scan Response of extended adv #define GAP_SCAN_EVT_EXT_SCAN_RSP 0x14 //!< Scan Response of extended scan response #define GAP_SCAN_EVT_PER_ADV 0x20 //!< Periodic adv /** @} EndGAP_SCAN_EVT_TYPE_DEFINES */ /** @defgroup GAP_APPEARANCE_VALUES GAP Appearance Values * @{ */ #define GAP_APPEARE_UNKNOWN 0x0000 //!< Unknown #define GAP_APPEARE_GENERIC_PHONE 0x0040 //!< Generic Phone #define GAP_APPEARE_GENERIC_COMPUTER 0x0080 //!< Generic Computer #define GAP_APPEARE_GENERIC_WATCH 0x00C0 //!< Generic Watch #define GAP_APPEARE_WATCH_SPORTS 0x00C1 //!< Watch: Sports Watch #define GAP_APPEARE_GENERIC_CLOCK 0x0100 //!< Generic Clock #define GAP_APPEARE_GENERIC_DISPLAY 0x0140 //!< Generic Display #define GAP_APPEARE_GENERIC_RC 0x0180 //!< Generic Remote Control #define GAP_APPEARE_GENERIC_EYE_GALSSES 0x01C0 //!< Generic Eye-glasses #define GAP_APPEARE_GENERIC_TAG 0x0200 //!< Generic Tag #define GAP_APPEARE_GENERIC_KEYRING 0x0240 //!< Generic Keyring #define GAP_APPEARE_GENERIC_MEDIA_PLAYER 0x0280 //!< Generic Media Player #define GAP_APPEARE_GENERIC_BARCODE_SCANNER 0x02C0 //!< Generic Barcode Scanner #define GAP_APPEARE_GENERIC_THERMOMETER 0x0300 //!< Generic Thermometer #define GAP_APPEARE_GENERIC_THERMO_EAR 0x0301 //!< Thermometer: Ear #define GAP_APPEARE_GENERIC_HR_SENSOR 0x0340 //!< Generic Heart rate Sensor #define GAP_APPEARE_GENERIC_HRS_BELT 0x0341 //!< Heart Rate Sensor: Heart Rate Belt #define GAP_APPEARE_GENERIC_BLOOD_PRESSURE 0x0380 //!< Generic Blood Pressure #define GAP_APPEARE_GENERIC_BP_ARM 0x0381 //!< Blood Pressure: Arm #define GAP_APPEARE_GENERIC_BP_WRIST 0x0382 //!< Blood Pressure: Wrist #define GAP_APPEARE_GENERIC_HID 0x03C0 //!< Generic Human Interface Device (HID) #define GAP_APPEARE_HID_KEYBOARD 0x03C1 //!< HID Keyboard #define GAP_APPEARE_HID_MOUSE 0x03C2 //!< HID Mouse #define GAP_APPEARE_HID_JOYSTIC 0x03C3 //!< HID Joystick #define GAP_APPEARE_HID_GAMEPAD 0x03C4 //!< HID Gamepad #define GAP_APPEARE_HID_DIGITIZER_TYABLET 0x03C5 //!< HID Digitizer Tablet #define GAP_APPEARE_HID_DIGITAL_CARDREADER 0x03C6 //!< HID Card Reader #define GAP_APPEARE_HID_DIGITAL_PEN 0x03C7 //!< HID Digital Pen #define GAP_APPEARE_HID_BARCODE_SCANNER 0x03C8 //!< HID Barcode Scanner /** @} End GAP_APPEARANCE_VALUES */ struct gap_ble_addr { uint8_t addr_type; //!< Address type: 0=public/1=random struct { uint8_t addr[6]; } addr; //!< Address value }; typedef struct gap_adv_param { enum gap_adv_mode adv_mode; //!< Advertising mode, ref @ gap_adv_mode enum gap_adv_disc_mode disc_mode; //!< Advertising discovery mode, ref @gap_adv_disc_mode //!< When adv_mode is in directional mode, disc_mode should be set to GAP_ADV_DISC_MODE_NON_DISC //!< When adv_mode is GAP_ADV_MODE_BEACON, disc_mode should be set to GAP_ADV_DISC_MODE_BEACON enum gap_adv_filter filt_policy; //!< Advertising filter policy, ref @ gap_adv_filter //!< When disc_mode is GAP_ADV_DISC_MODE_GEN_DISC or GAP_ADV_DISC_MODE_LIM_DISC, //!< filt_policy should be set to GAP_ADV_FILTER_SCAN_ANY_CON_ANY enum gap_adv_chan adv_chnl_map; //!< Advertising channal map, 37, 38, 39, ref @ gap_adv_chan enum gap_phy_type phy_mode; //!< ref @gap_phy_type enum gap_own_addr_type own_addr_type; //!< Own address type, ref @gap_own_addr_type struct gap_ble_addr peer_addr; //!< Peer addr used for connect, used for direction adv uint16_t adv_intv_min; //!< Minimum advertising interval, (in unit of 625us). Must >= 32 uint16_t adv_intv_max; //!< Maximum advertising interval, (in unit of 625us). Must >= 32 /* the following is for secondary advertising configuration */ uint8_t max_skip; //!< 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 enum gap_phy_type second_phy_mode; //!< PHY mode for secondary advertising ref @gap_phy_type uint8_t adv_sid; //!< Advertising set idx, for EXTENDED adv and PERIODIC ADV only, range:0~0xF /* the following is for periodic advertising */ uint16_t per_adv_intv_min; //!< Minimum periodic advertising interval (in unit of 1.25ms).. Must be greater than 20ms,for PERIODIC ADV only uint16_t per_adv_intv_max; //!< Maximum periodic advertising interval (in unit of 1.25ms). Must be greater than 20ms,for PERIODIC ADV only }gap_adv_param_t; typedef struct gap_scan_param { enum gap_scan_type scan_type; //!< scan type, ref @ gap_scan_type enum gap_own_addr_type own_addr_type; //!< Own address type, ref @gap_own_addr_type enum gap_phy_type phy_mode; //!< ref @gap_phy_type uint8_t dup_filt_pol; //!< scan duplicated pkt filter enbale, 0, donot filter; 1 filter duplicated pkt uint16_t scan_intv; //!< scan interval, (in unit of 625us). range [4,16384] uint16_t scan_window; //!< scan window, (in unit of 625us). must <= scan_intv, range [4,16384] uint16_t duration; //!< Scan duration (in unit of 10ms). 0 means that the controller will scan continuously until host stop it }gap_scan_param_t; typedef struct gap_conn_param { struct gap_ble_addr peer_addr; //!< Peer addr used for connect enum gap_own_addr_type own_addr_type; //!< Own address type, ref @gap_own_addr_type enum gap_phy_type phy_mode; //!< ref @gap_phy_type uint16_t scan_intv; //!< scan interval, (in unit of 625us). range [4,16384] uint16_t scan_window; //!< scan window, (in unit of 625us). must <= scan_intv, range [4,16384] uint16_t conn_intv_min; //!< connection minimum interval (in unit of 1.25ms), should less than conn_intv_max uint16_t conn_intv_max; //!< connection maximum interval (in unit of 1.25ms), range is 7.5ms to 4s uint16_t supervision_to; //!< link supervision timeout (in unit of 10ms) uint16_t slave_latency; //!< number of events than can be missed by a connected slave device uint16_t ce_len_min; //!< maximum duration of connection event (in unit of 625us) uint16_t ce_len_max; //!< minumum duration of connection event (in unit of 625us) }gap_conn_param_t; typedef struct gap_evt_adv_report { uint8_t evt_type; //!< Bit field providing information about the received report (@see GAP_SCAN_EVT_TYPE_DEFINES) struct gap_ble_addr addr; //!< Target address (in case of a directed advertising report) int8_t tx_pwr; //!< TX power (in dBm) int8_t rssi; //!< RSSI (between -127 and +20 dBm) uint16_t length; //!< Report length const uint8_t *data; //!< Report data }gap_evt_adv_report_t; typedef struct gap_evt_conn_param { uint8_t conidx; //!< Connection index struct gap_ble_addr peer_addr; //!< Peer addr used for connect uint16_t con_interval; //!< Connection interval uint16_t con_latency; //!< Slave latency uint16_t sup_to; //!< Supervision timeout }gap_evt_conn_param_t; typedef struct gap_evt_disconnect { uint8_t conidx; //!< Connection index uint8_t reason; //!< Disconnect reason }gap_evt_disconnect_t; typedef struct gap_evt_link_param_reject { uint8_t conidx; //!< Connection index uint8_t status; //!< Parameter reject status }gap_evt_link_param_reject_t; typedef struct gap_evt_link_param_update { uint8_t conidx; //!< Connection index uint16_t con_interval; //!< Connection interval uint16_t con_latency; //!< Connection latency value uint16_t sup_to; //!< Supervision timeout }gap_evt_link_param_update_t; typedef struct gap_evt_link_param_update_req { uint8_t conidx; //!< Connection index uint16_t intv_min; //!< Connection interval minimum uint16_t intv_max; //!< Connection interval maximum uint16_t latency; //!< Latency uint16_t time_out; //!< Supervision timeout }gap_evt_link_param_update_req_t; // Link parameter update rsponse event typedef struct gap_evt_link_param_update_rsp { bool accept; uint8_t conidx; //!< Connection index uint16_t ce_len_min; //!< Mimimum Connection Event Duration uint16_t ce_len_max; //!< Maximum Connection Event Duration }gap_evt_link_param_update_rsp_t; typedef struct gap_link_param_update_req { uint8_t conidx; //!< Connection index uint16_t intv_min; //!< Connection interval minimum uint16_t intv_max; //!< Connection interval maximum uint16_t latency; //!< Latency uint16_t time_out; //!< Supervision timeout }gap_link_param_update_req_t; typedef struct gap_link_param_update_rsp { bool accept; uint8_t conidx; //!< Connection index uint16_t ce_len_min; //!< Mimimum Connection Event Duration uint16_t ce_len_max; //!< Maximum Connection Event Duration }gap_link_param_update_rsp_t; typedef struct gap_security_param { bool mitm; //!< Man In The Middle mode enalbe/disable bool secure_connection; //!< BLE Secure Simple Pairing, also called Secure Connection mode. bool bond; //!< Bond or not, if true, then will distribute encryption key, and will check this key_req when bonding. enum gap_sec_mode rsp_mode; //!< Security rsp mode, ref @enum gap_sec_mode enum gap_oob oob_used; //!< Oob data exists or not, ref @enum gap_oob enum gap_io_cap io_cap; //!< IO capbilities, ref @enum gap_io_cap }gap_security_param_t; typedef struct gap_bond_ltk { uint8_t ltk[16]; //!< Long Term Key uint16_t ediv; //!< Encryption Diversifier uint8_t randnb[8]; //!< Random Number uint8_t key_size; //!< Encryption key size (7 to 16) }gap_bond_ltk_t; typedef struct gap_bond_info { uint8_t conidx; //!< Connection index uint8_t status; //!< Pairing results, 0x00 means success struct gap_ble_addr peer_addr; //!< Peer addr used for connect struct gap_ble_addr peer_id_addr; //!< Peer identity address uint8_t peer_irk[16]; //!< Peer irk struct gap_bond_ltk peer_ltk; //!< Peer ltk }gap_bond_info_t; typedef struct gap_channel_map { uint8_t conidx; //!< Connection index uint8_t map[5]; //!< 5-byte channel map array }gap_channel_map_t; struct gap_event { enum gap_event_type type; //!< GAP event type union { uint8_t conidx; struct { uint8_t act_id; uint8_t status; } adv_set_param; struct { uint8_t act_id; uint8_t status; } adv_set_adv_data; struct { uint8_t act_id; uint8_t status; } adv_set_scan_rsp; struct { uint8_t act_id; uint8_t status; } adv_set_period_data; struct { uint8_t act_id; uint8_t status; } adv_start; struct { uint8_t act_id; uint8_t status; } adv_end; //!< Advertising end status uint8_t scan_start_status; //!< Scanning end status uint8_t scan_end_status; //!< Scanning end status struct gap_evt_adv_report *adv_rpt; //!< Value of GAP_EVT_ADV_REPORT event, scanning results uint8_t conn_start_status; //!< Connection end reason uint8_t conn_end_status; //!< Connection end reason struct { uint8_t conidx; uint8_t token; } name_req; //!< Value of GAP_EVT_NAME_REQ event struct { uint8_t conidx; uint8_t token; } slv_pref_param_req; //!< Value of GAP_EVT_SLAVE_PREF_PARAM event struct { uint8_t conidx; uint8_t token; } appearance_req; //!< Value of GAP_EVT_APPEARANCE_REQ event struct gap_evt_conn_param connect; //!< Value of GAP_EVT_MASTER_CONNECT or GAP_EVT_SLAVE_CONNECT event struct gap_evt_disconnect disconnect; //!< Value of GAP_EVT_DISCONNECT event struct { uint8_t conidx; uint32_t number; } nc_req; //!< Value of GAP_EVT_SMP_NC_REQ struct { uint8_t conidx; enum smp_tk_type tk_type; } tk_req; //!< Value of GAP_EVT_SMP_TK_REQ event struct { uint8_t conidx; } pair_req; //!< Value of GAP_EVT_SMP_PAIR_REQ event struct { uint8_t conidx; } security_req; //!< Value of GAP_EVT_SMP_SEC_REQ event struct gap_bond_info bond; //!< Value of GAP_EVT_SMP_BOND_SUCCESS and GAP_EVT_SMP_BOND_FAILED event struct { uint8_t conidx; uint8_t ltk[16]; //!< Can be used for gap_encrypt_rsp() } encrypt_req; //!< Value of GAP_EVT_SMP_ENCRYPT_REQ event struct { uint8_t conidx; uint8_t status; //!< Encrypt status, 0x00 means success } encrypt; //!< Value of GAP_EVT_SMP_ENCRYPT_SUCCESS or GAP_EVT_SMP_ENCRYPT_FAILED event struct gap_evt_link_param_reject link_param_reject; //!< Value of GAP_EVT_LINK_PARAM_REJECT event, Connect param reject struct gap_evt_link_param_update link_param_update; //!< Value of GAP_EVT_LINK_PARAM_UPDATE event, Connect param update struct gap_evt_link_param_update_req link_param_update_req; //!< Value of GAP_EVT_LINK_PARAM_REQ event struct gap_evt_link_param_update_rsp link_param_update_rsp; struct { uint8_t conidx; uint16_t mtu; } mtu_ind; //!< Value of GATT_EVT_MTU event, mtu update indication struct { uint8_t conidx; int8_t link_rssi; //!< Peer device RSSI value } gap_link_rssi; //!< Value of GAP_EVT_LINK_RSSI event struct { uint8_t conidx; //!< Connection index uint16_t compid; //!< Manufacturer name uint16_t lmp_subvers; //!< LMP subversion uint8_t lmp_vers; //!< LMP version } gap_link_ver; //!< Value of GAP_EVT_LINK_VER event struct { uint8_t conidx; //!< Connection index uint8_t features[8]; //!< Features bitmask } gap_link_feature; //!< Value of GAP_EVT_LINK_FEATURE event struct { uint8_t conidx; uint8_t tx_phy; //!< ref @gapm_phy_type uint8_t rx_phy; //!< ref @gapm_phy_type } gap_phy_ind; //!< Value of GAP_EVT_PHY_IND event, PHY update success event or get phy success struct { uint8_t conidx; uint8_t status; //!< Reason of reject } gap_phy_update_reject; //!< Value of GAP_EVT_PHY_REJECT event, PHY update rejected event uint8_t add_device_to_wl_status; //!< Value of GAP_EVT_ADD_DEVICE_TO_WL event uint8_t rmv_device_from_wl_status; //!< Value of GAP_EVT_RMV_DEVICE_FROM_WL event uint8_t add_device_to_ral_status; //!< Value of GAP_EVT_ADD_DEVICE_TO_TAL event uint8_t profile_added_status; //!< Value of GATT_EVT_PROFILE_ADDED event, profile added status } param; }; typedef void *adv_handle; typedef uint16_t(*gap_callback_func_t)(struct gap_event *event); //!< Gap callback function define /* Exported constants --------------------------------------------------------*/ /* Exported macro ------------------------------------------------------------*/ /* Private macros ------------------------------------------------------------*/ /* Exported variables --------------------------------------------------------*/ extern gap_callback_func_t gap_evt_callback; /* Exported functions --------------------------------------------------------*/ /* * @fn gap_reset_local_address * * @brief reset local static address(public or random static). * Must stop advertising before configure. * After address change, the advertising parameters and data must be reset * * @param[in] new_addr : pointer to new address info * * @return @ref ble_api_err_t */ ble_api_err_t gap_reset_local_address(struct gap_ble_addr *new_addr); /* * @fn gap_adv_create * * @brief Create an advertising activity before any advertising operation. This * function will return a handle used by following operations. * * @return operation handle */ adv_handle gap_adv_create(void); /* * @fn gap_get_adv_state * * @brief Obtain the state of the specified advertising. * * @param[in] adv : advertising operation handle * * @return enum gap_adv_state */ enum gap_adv_state gap_get_adv_state(adv_handle adv); /* * @fn gap_adv_set_param * * @brief used to create advertising entity with parameters defined by user * * @param[in] adv : advertising operation handle * @param[in] param : advertising parameters * * @return @ref ble_api_err_t */ ble_api_err_t gap_adv_set_param(adv_handle adv, struct gap_adv_param *param); /* * @fn gap_adv_set_adv_type_flag * * @brief user to set advertising type flag * * @param[in] adv_type: adv type flag * * @return None */ void gap_adv_set_adv_type_flag(enum adv_type_flag adv_type); /* * @fn gap_adv_set_adv_data * * @brief used to set advertising data * * @param[in] adv : advertising operation handle * @param[in] data : advertising data buffer pointer * @param[in] length : advertising data length * * @return @ref ble_api_err_t */ ble_api_err_t gap_adv_set_adv_data(adv_handle adv, const uint8_t *data, uint16_t length); /* * @fn gap_adv_set_scan_rsp * * @brief used to set scan response data * * @param[in] adv : advertising operation handle * @param[in] data : scan response data buffer pointer * @param[in] length : scan response data length * * @return @ref ble_api_err_t */ ble_api_err_t gap_adv_set_scan_rsp(adv_handle adv, const uint8_t *data, uint16_t length); /* * @fn gap_adv_set_period_data * * @brief used to set periodic advertising data * * @param[in] adv : advertising operation handle * @param[in] data : periodic advertising data buffer pointer * @param[in] length : periodic advertising data length * * @return @ref ble_api_err_t */ ble_api_err_t gap_adv_set_period_data(adv_handle adv, const uint8_t *data, uint16_t length); /* * @fn gap_adv_start * * @brief start advertising * * @param[in] adv : advertising operation handle * @param[in] duration : advertising duration, unit: 10ms. 0 means that advertising will not terminate * automaticly. * @param[in] max_adv_evt : Maximum number of extended advertising events the controller shall attempt to send prior to * terminating the extending advertising. Valid only if extended advertising. * 0 means taht extended advertising events will always be sent * * @return @ref ble_api_err_t */ ble_api_err_t gap_adv_start(adv_handle adv, uint16_t duration, uint8_t max_adv_evt); /* * @fn gap_adv_stop * * @brief stop on-going advertising * * @param[in] adv : advertising operation handle * * @return @ref ble_api_err_t */ ble_api_err_t gap_adv_stop(adv_handle adv); /* * @fn gap_scan_start * * @brief start scan advertising devices * * @param[in] param : scan parameters * * @return @ref ble_api_err_t */ ble_api_err_t gap_scan_start(struct gap_scan_param *param); /* * @fn gap_scan_stop * * @brief stop on-going scan * * @return @ref ble_api_err_t */ ble_api_err_t gap_scan_stop(void); /* * @fn gap_conn_start * * @brief start connect request to remote device, this function should not be called when * there is an on-going connection request. * * @param[in] param : connection parameters * * @return @ref ble_api_err_t */ ble_api_err_t gap_conn_start(struct gap_conn_param *param); /* * @fn gap_conn_stop * * @brief stop out-going connection request * * @return @ref ble_api_err_t */ ble_api_err_t gap_conn_stop(void); /* * @fn gap_disconnect * * @brief remove an existing connection * * @param[in] conidx : connection index * * @return @ref ble_api_err_t */ ble_api_err_t gap_disconnect(uint8_t conidx); /* * @fn gap_get_connect_num * * @brief get the current active connections number * * @return number of active connections */ uint8_t gap_get_connect_num(void); /* * @fn gap_get_connect_num_through_role * * @brief get the current active connections number through local devices role * * @param[in] role : local device role * * @return number of active connections */ uint8_t gap_get_connect_num_through_role(enum local_device_con_role role); /* * @fn gap_get_local_role * * @brief Get the local device role * * @param[in] conidx : connection index * * @return the connection role */ enum local_device_con_role gap_get_local_dev_role(uint8_t conidx); /* * @fn gap_get_connect_status * * @brief Get the connection status with a peer device * * @param[in] conidx : connection index * * @return the connection status */ bool gap_get_connect_status(uint8_t conidx); /* * @fn gap_act_done * * @brief this function will be called after action has been handled by host layer * * @param[in] operation : last requested action * @param[in] status : handle result * @param[in] act_id : action id */ void gap_act_done(uint8_t operation, uint8_t status, uint8_t act_id); /* * @fn gap_param_update_rsp * * @brief stop out-going connection request * * @param[in] rsp : link param update response parameters, @ref gap_evt_link_param_update_rsp * * @return @ref ble_api_err_t */ ble_api_err_t gap_param_update_rsp(struct gap_link_param_update_rsp *rsp); /* * @fn gap_param_update_req * * @brief send connection parameters update request from ble peripheral device. * * @param[in] req : link param update request parameters, @ref gap_evt_link_param_update_rsp * * @return @ref ble_api_err_t */ ble_api_err_t gap_param_update_req(struct gap_link_param_update_req *req); /* * @fn gap_name_req_rsp * * @brief send response to name request from GAP * * @param[in] conidx: connection index * @param[in] token: received from GAP_EVT_NAME_REQ * @param[in] length: name length * @param[in] name: name string * * @return @ref ble_api_err_t */ ble_api_err_t gap_name_req_rsp(uint8_t conidx, uint8_t token, uint16_t length, uint8_t *name); /* * @fn gap_appearance_req_rsp * * @brief send response to appearance request from GAP * * @param[in] conidx: connection index * @param[in] token: received from GAP_EVT_NAME_REQ * @param[in] appearance: appearance, see @defgroup GAP_APPEARANCE_VALUES * * @return @ref ble_api_err_t */ ble_api_err_t gap_appearance_req_rsp(uint8_t conidx, uint8_t token, uint16_t appearance); /* * @fn gap_slave_pref_param_req_rsp * * @brief send response to slave prefer parameter request from GAP * * @param[in] conidx: connection index * @param[in] token: received from GAP_EVT_NAME_REQ * @param[in] con_intv_min: minimum connection interval * @param[in] con_intv_max: maximum connection interval * @param[in] slave_latency: slave latency * @param[in] conn_timeout: connection timeout * * @return @ref app_err_t */ ble_api_err_t gap_slave_pref_param_req_rsp(uint8_t conidx, uint8_t token, uint16_t con_intv_min, uint16_t con_intv_max, uint16_t slave_latency, uint16_t conn_timeout); /* * @fn gap_set_cb_func * * @brief GAP callback functions set. Links application layer callbacks to GAP layer. * * @param[in] gap_evt_cb : Application layer callback function, defined in application layer. * * @return @ref ble_api_err_t */ ble_api_err_t gap_set_cb_func(gap_callback_func_t gap_evt_cb); /* * @fn gap_security_param_init * * @brief Used to set SMP parameters. * * @param[in] sec_param : SMP parameters. @ref gap_security_param. * * @return @ref ble_api_err_t */ ble_api_err_t gap_security_param_init(struct gap_security_param *sec_param); /* * @fn gap_security_tk_rsp * * @brief Used to response Temporary Key request from GAP in pairing procedure. When local io-cap is * GAP_IO_CAP_DISPLAY_ONLY, this function is used to send local generated TK, also this value * should be showed in display. When local io-cap is GAP_IO_CAP_KB_ONLY, this function is used * to send local TK input by keyboard. * * @param[in] conidx : connection index * @param[in] tk : temporary key, the value should be between 100000 and 999999 * @param[in] accept: true:Agree to pairing, false:Refuse pairing * * @return @ref ble_api_err_t */ ble_api_err_t gap_security_tk_rsp(uint8_t conidx, uint32_t tk, bool accept); /* * @fn gap_security_nc_rsp * * @brief Used to response Numbric Comparision request from GAP in pairing procedure. * * @param[in] conidx : connection index * @param[in] accept: true:Agree to pairing, false:Refuse pairing * * @return @ref ble_api_err_t */ ble_api_err_t gap_security_nc_rsp(uint8_t conidx, bool accept); /* * @fn gap_security_req * * @brief Used to send security request when the deivice is the slaver * * @param[in] conidx : connection index * * @return @ref ble_api_err_t */ ble_api_err_t gap_security_req(uint8_t conidx); /* * @fn gap_pairing_req * * @brief Used to send pairing request when the device is the master * * @param[in] conidx : connection index * * @return @ref ble_api_err_t */ ble_api_err_t gap_pairing_req(uint8_t conidx); /* * @fn gap_pairing_rsp * * @brief Used to send pairing response when event GAP_EVT_SMP_PAIR_REQ occurs * * @param[in] conidx : connection index * @param[in] accept : true - Agree to pairing req. * false - Refuse pairing req * * @return @ref ble_api_err_t */ ble_api_err_t gap_pairing_rsp(uint8_t conidx, bool accept); /* * @fn gap_encrypt_req * * @brief Used to send encrypt request when the device is the master * * @param[in] conidx : connection index * * @return @ref ble_api_err_t */ ble_api_err_t gap_encrypt_req(uint8_t conidx); /* * @fn gap_encrypt_rsp * * @brief Used to send encrypt response when event GAP_EVT_SMP_ENCRYPT_REQ occurs * * @param[in] conidx : connection index * @param[in] ltk : long Term Key information * @param[in] accept : true - Agree to encryption req. * false - Refuse encryption req * * @return @ref ble_api_err_t */ ble_api_err_t gap_encrypt_rsp(uint8_t conidx, uint8_t *ltk, bool accept); /* * @fn gap_get_bond_status * * @brief Get bond info status of peer device. * * @param[in] conidx : connection index * * @return @ref true: bond info existed, false: bond info not existed */ bool gap_get_bond_status(uint8_t conidx); /* * @fn gap_get_encrypted_status * * @brief Get encrypted status of peer device. * * @param[in] conidx : connection index * * @return @ref encrypted status */ bool gap_get_encrypted_status(uint8_t conidx); /* * @fn gap_get_bond_info * * @brief Get a bond information. * * @param[in] bond_info_list_index - index of the bond information list in the ble stack. * range:0 ~ 7. * @param[in] out_bond_info - pointer to bond info * * @return @ref ble_api_err_t */ ble_api_err_t gap_get_bond_info(uint8_t bond_info_list_index, gap_bond_info_t *out_bond_info); /* * @fn gap_get_bond_info_by_conidx * * @brief Get a bond information by conidx. * The device of this conidx needs to be in a connected state. * * @param[in] conidx : connection index * @param[in] out_bond_info - pointer to bond info * * @return @ref ble_api_err_t */ ble_api_err_t gap_get_bond_info_by_conidx(uint8_t conidx, gap_bond_info_t *out_bond_info); /* * @fn gap_delete_bond_info * * @brief Erase a bond information. * * @param[in] peer_id_addr - pointer to peer device identity address * * @return @ref ble_api_err_t */ ble_api_err_t gap_delete_bond_info(struct gap_ble_addr *peer_id_addr); /* * @fn gap_deletet_all_bond_info * * @brief Erase all bond information. * * @return @ref ble_api_err_t */ ble_api_err_t gap_deletet_all_bond_info(void); /* * @fn gap_get_conn_phy * * @brief Read active link PHY mode. * The phy report will be uploaded to user laye as GAP_EVENT:GAP_EVT_PHY_IND. * This function sample is: * case GAP_EVT_PHY_IND: * co_printf("link tx phy: %d\r\n",event->param.gap_phy_ind.tx_phy); * ... * break; * * @param[in] conidx : connection index * * @return @ref ble_api_err_t */ ble_api_err_t gap_get_conn_phy(uint8_t conidx); /* * @fn gap_conn_phy_update * * @brief Set active link PHY mode. * * @param[in] conidx : connection handle/index of the connection. * @param[in] tx_phy : TX PHY mode. //!< see @enum gapm_phy_mode * @param[in] rx_phy : RX PHY mode. //!< see @enum gapm_phy_mode * * @return @ref ble_api_err_t */ ble_api_err_t gap_conn_phy_update(uint8_t conidx, enum gap_phy_type tx_phy, enum gap_phy_type rx_phy); /* * @fn gap_get_link_rssi * * @brief Used to send a request to lower layer to get current rssi of link peer device. * The rssi report will be uploaded to user laye as GAP_EVENT:GAP_EVT_LINK_RSSI. * This function sample is: * case GAP_EVT_LINK_RSSI: * co_printf("link rssi: %d\r\n",event->param.gap_link_rssi.link_rssi); * ... * break; * * @param[in] conidx : connection index * * @return @ref ble_api_err_t */ ble_api_err_t gap_get_link_rssi(uint8_t conidx); /* * @fn gap_get_link_features * * @brief Used to send a request to lower layer to get features of link peer device. * The feature report will be uploaded to user laye as GAP_EVENT:GAP_EVT_LINK_FEATURE. * * @param[in] conidx : connection index * * @return @ref ble_api_err_t */ ble_api_err_t gap_get_link_features(uint8_t conidx); /* * @fn gap_get_link_version * * @brief Used to send a request to lower layer to get version info of link peer device. * The phy report will be uploaded to user laye as GAP_EVENT:GAP_EVT_LINK_VER. * * @param[in] conidx : connection index * * @return @ref ble_api_err_t */ ble_api_err_t gap_get_link_version(uint8_t conidx); /* * @fn gap_add_device_to_white_list * * @brief Add device to white list. * * @param[in] peer_id_addr - pointer to peer device identity address, which will be added to white list * @param[in] size - device number,rang:1~22. how many devices will be added to white list * * @return @ref ble_api_err_t */ ble_api_err_t gap_add_device_to_white_list(struct gap_ble_addr *peer_id_addr, uint8_t size); /* * @fn gap_remove_device_from_white_list * * @brief Remove device from white list. * * @param[in] peer_id_addr - pointer to peer device identity address, which will be removed from white list * @param[in] size - device number,range:0~22. how many devices will be removed from white list. * when size is 0, All devices in the white list will be removed * * @return @ref ble_api_err_t */ ble_api_err_t gap_remove_device_from_white_list(struct gap_ble_addr *peer_id_addr, uint8_t size); /* * @fn gap_add_device_to_resolve_list * * @brief Add device to resolve list. * * @param[in] peer_id_addr - pointer to peer device identity address, which will be added to resolve list * @param[in] irk_array - peer device irk array.Each irk has a length of 16. * @param[in] size - device number,range:1~3. how many devices will be added to resolve list. * * @return @ref ble_api_err_t */ ble_api_err_t gap_add_device_to_resolve_list(struct gap_ble_addr *peer_id_addr, uint8_t *irk_array, uint8_t size); #ifdef __cplusplus } #endif #endif // _GAP_API_H