ad_ble.h

Go to the documentation of this file.

 
#ifndef AD_BLE_H
#define AD_BLE_H
 
#include "osal.h"
 
#include "ad_ble_config.h"
 
#include "ad_nvparam.h"
#include "ble_config.h"
#include "co_bt.h"
 
 
/* Event group bits */
#define mainBIT_BLE_GEN_IRQ             (1 << 0)
#define mainBIT_COMMAND_QUEUE           (1 << 1)
#define mainBIT_EVENT_QUEUE_AVAIL       (1 << 2)
#define mainBIT_EVENT_LPCLOCK_AVAIL     (1 << 3)
#define mainBIT_STAY_ACTIVE_UPDATED     (1 << 4)
#define mainBIT_BLE_CMAC_IRQ            (1 << 5)
#define mainBIT_BLE_TIMER_EXPIRED       (1 << 6)
#define mainBIT_BLE_STACK_READ_CB       (1 << 7)
#define mainBIT_TEMP_MONITOR_ENABLE     (1 << 9)
#define mainBIT_TEMP_MONITOR_DISABLE    (1 << 10)
#define mainBIT_BLE_RF_CALIBRATION      (1 << 11)
#if (dg_configBLE_ADV_STOP_DELAY_ENABLE == 1)
#define mainBIT_EVENT_ADV_END           (1 << 31)
#endif
 
#define HCI_CMD_HEADER_LENGTH      3
#define HCI_ACL_HEADER_LENGTH      4
#define HCI_SCO_HEADER_LENGTH      3
#define HCI_EVT_HEADER_LENGTH      2
#define GTL_MSG_HEADER_LENGTH      8
 
#define HCI_CMD_PARAM_LEN_OFFSET   3
#define HCI_ACL_PARAM_LEN_OFFSET   3
#define HCI_SCO_PARAM_LEN_OFFSET   3
#define HCI_EVT_PARAM_LEN_OFFSET   2
#define GTL_MSG_PARAM_LEN_OFFSET   7
 
#define HCI_RESET_CMD_OP_CODE      (0x0C03)
 
// Maximum wait time for BLE stack configuration operations
#define MAX_WAIT_TIME  portMAX_DELAY
 
// Operations for BLE adapter messages
typedef enum ad_ble_op_codes {
        AD_BLE_OP_CODE_STACK_MSG      = 0x00,
        AD_BLE_OP_CODE_ADAPTER_MSG    = 0x01,
        /*
         * last command ID
         * make sure above are sorted in ascending order, otherwise this one will be incorrect!
         */
        AD_BLE_OP_CODE_LAST,
} ad_ble_op_code_t;
 
// Operations for BLE adapter messages
typedef enum ad_ble_operations {
        AD_BLE_OP_CMP_EVT     = 0x00,
        AD_BLE_OP_INIT_CMD    = 0x01,
        AD_BLE_OP_RESET_CMD   = 0x02,
        /*
         * last command ID
         * make sure above are sorted in ascending order, otherwise this one will be incorrect!
         */
        AD_BLE_OP_LAST,
} ad_ble_operation_t;
 
// Statuses for BLE adapter operations
typedef enum ad_ble_statuses {
        AD_BLE_STATUS_NO_ERROR    = 0x00,
        AD_BLE_STATUS_TIMEOUT     = 0x01,
        /*
         * last error code for BLE adapter operations
         * make sure above are sorted in ascending order, otherwise this one will be incorrect!
         */
        BLE_ADAPTER_OP_LAST
} ad_ble_status_t;
 
// Statuses for BLE stack I/O callback operations
enum ad_ble_stack_statuses {
        BLE_STACK_IO_OK    = 0x00,
        BLE_STACK_IO_ERROR = 0x01,
        /*
         * last error code for BLE stack I/O operations
         * make sure above are sorted in ascending order, otherwise this one will be incorrect!
         */
        BLE_STACK_IO_LAST
};
 
typedef enum {
        BLE_HCI_CMD_MSG  = 0x01,
        BLE_HCI_ACL_MSG  = 0x02,
        BLE_HCI_SCO_MSG  = 0x03,
        BLE_HCI_EVT_MSG  = 0x04,
        BLE_GTL_MSG      = 0x05,
#ifdef CONFIG_USE_FTDF
        FTDF_DTS_MSG     = 0xAA,
#endif
} ble_msg_type_t;
 
typedef uint16_t hci_cmd_op_code_t;
typedef uint16_t hci_cmd_op_code_t;
 
typedef struct ble_hci_cmd_hdr {
        uint8_t op_code_l;
        uint8_t op_code_h;
        uint8_t data_length;
} ble_hci_cmd_hdr_t;
 
typedef struct ble_hci_acl_msg_hdr {
        uint16_t handle_flags;
        uint16_t data_length;
} ble_hci_acl_hdr_t;
 
typedef struct ble_hci_sco_hdr {
        uint16_t conn_handle_flags;
        uint8_t data_length;
} ble_hci_sco_hdr_t;
 
typedef struct ble_hci_evt_hdr {
        uint8_t event_code_;
        uint8_t data_length;
} ble_hci_evt_hdr_t;
 
typedef struct hci_cmd_msg {
        uint16_t op_code;
        uint8_t  param_length;
        uint8_t  param[0];
} hci_cmd_msg_t;
 
typedef struct hci_acl_msg {
        uint16_t handle_flags;
        uint16_t param_length;
        uint8_t  param[0];
} hci_acl_msg_t;
 
typedef struct hci_sco_msg {
        uint16_t handle_flags;
        uint8_t  param_length;
        uint8_t  param[0];
} hci_sco_msg_t;
 
typedef struct hci_evt_msg {
        uint8_t event_code;
        uint8_t param_length;
        uint8_t param[0];
} hci_evt_msg_t;
 
typedef struct ble_hci_msg {
        union {
                hci_cmd_msg_t cmd;
                hci_acl_msg_t acl;
                hci_sco_msg_t sco;
                hci_evt_msg_t evt;
        };
} ble_hci_msg_t;
 
typedef struct ble_gtl_msg {
        uint16_t msg_id;
        uint16_t dest_id;
        uint16_t src_id;
        uint16_t param_length;
        uint32_t param[0];
} ble_gtl_msg_t;
 
typedef struct ble_stack_msg {
        union {
                ble_gtl_msg_t gtl;
                ble_hci_msg_t hci;
        };
} ble_stack_msg_t;
 
typedef struct ad_ble_msg {
        uint16_t            op_code;
        uint16_t            msg_size;
        ad_ble_operation_t  operation;
        uint8_t             param[0];
} ad_ble_msg_t;
 
typedef struct ad_ble_hdr {
        uint16_t    op_code;
        uint16_t    msg_size;
        uint8_t     param[0];
} ad_ble_hdr_t;
 
typedef struct {
        OS_TASK  task;     
        OS_QUEUE cmd_q;    
        OS_QUEUE evt_q;    
} ad_ble_interface_t;
 
OS_BASE_TYPE ad_ble_command_queue_send( const void *item, OS_TICK_TIME wait_ticks);
 
void ad_ble_lpclock_available(void);
 
OS_BASE_TYPE ad_ble_event_queue_send( const void *item, OS_TICK_TIME wait_ticks);
 
void ad_ble_task_notify(uint32_t value);
 
void ad_ble_init(void);
 
const ad_ble_interface_t *ad_ble_get_interface(void);
 
OS_BASE_TYPE ad_ble_event_queue_register(const OS_TASK task_handle);
 
void ad_ble_get_public_address(uint8_t address[BD_ADDR_LEN]);
 
 
bool ad_ble_read_nvms_param(uint8_t* param, uint8_t len, uint8_t nvparam_tag, uint32_t nvms_addr);
 
void ad_ble_get_irk(uint8_t irk[KEY_LEN]);
 
void ad_ble_notify_event_queue_avail(void);
 
#if dg_configNVPARAM_ADAPTER
nvparam_t ad_ble_get_nvparam_handle(void);
#endif /* dg_configNVPARAM_ADAPTER */
 
void ad_ble_stay_active(bool status);
 
#if (dg_configRF_ENABLE_RECALIBRATION == 1)
 
void ad_ble_notify_rf_calibration(void);
#endif /* (dg_configRF_ENABLE_RECALIBRATION == 1) */
 
bool ad_ble_non_retention_heap_in_use(void);
 
#if (USE_BLE_SLEEP == 1)
 
void ad_ble_update_wakeup_time(void);
#endif /* USE_BLE_SLEEP */
 
void ad_ble_sys_tcs_config(void);
 
#if (dg_configUSE_SYS_TCS == 1)
 
void ad_ble_tcs_config(void);
#endif
 
#if (dg_configRF_ENABLE_RECALIBRATION == 1)
 
void ad_ble_rf_calibration_info(void);
 
void ad_ble_set_rf_calibration_info(const uint32_t value);
#endif
 
struct ad_ble_lld_stats {
        // Total number of connection events
        uint32_t conn_evt_counter[BLE_CONNECTION_MAX_USER];
        // Number of connection events that completed without apfm status
        uint32_t conn_evt_counter_non_apfm[BLE_CONNECTION_MAX_USER];
        // Total number of advertising events
        uint32_t adv_evt_counter;
        // Number of advertising events that completed without apfm status
        uint32_t adv_evt_counter_non_apfm;
};
 
void ad_ble_get_lld_stats(struct ad_ble_lld_stats *stats);
 
#if (USE_BLE_SLEEP == 1)
#if (dg_configUSE_LP_CLK == LP_CLK_RCX)
 
void ad_ble_update_rcx(void);
#endif /* (USE_BLE_SLEEP == 1) */
#endif /* (dg_configUSE_LP_CLK == LP_CLK_RCX) */
 
 
#endif /* AD_BLE_H */