m2mb_ble.h

Go to the documentation of this file.

/*===============================================================================================*/
/*         >>> Copyright (C) Telit Communications S.p.A. Italy All Rights Reserved. <<<          */
#ifndef  M2MB_BLE_H
#define  M2MB_BLE_H
 
/* GLOBAL DECLARATIONS ==========================================================================*/
 
//#define M2MB_BLE_MAX_DEVICE_NAME_LENGTH         248
#define M2MB_BLE_MAX_DEVICE_NAME_LENGTH         (39+1) 
#define M2MB_BLE_MAX_MANUFACTURER_NAME_LENGTH   M2MB_BLE_MAX_DEVICE_NAME_LENGTH
#define M2MB_BLE_FIXPIN_SIZE                    6
#define M2MB_BLE_ADV_DATA_SIZE                  32
#define M2MB_BLE_SCAN_RSP_DATA_SIZE             32
#define M2MB_BLE_ADDRESS_RESOLUTION_TIMEOUT     60
#define M2MB_BLE_MTU_SIZE_MAX                   158
#define M2MB_BLE_BOND_ENTRIES_MAX               20
#define M2MB_BLE_MAX_ATTRIBUTE_LENGTH                       600
 
/* Max hex value string which can hold the Maximum MTU data */
#define M2MB_BLE_MAX_HEX_VALUE                  ((2 * M2MB_BLE_MTU_SIZE_MAX) + 1)
 
#define M2MB_BLE_MAX_PAIRED_DEVICES             4 
#define M2MB_BLE_ATT_PROTOCOL_ERROR_CODE_INVALID_HANDLE                      0x01
#define M2MB_BLE_ATT_PROTOCOL_ERROR_CODE_READ_NOT_PERMITTED                  0x02
#define M2MB_BLE_ATT_PROTOCOL_ERROR_CODE_WRITE_NOT_PERMITTED                 0x03
#define M2MB_BLE_ATT_PROTOCOL_ERROR_CODE_INVALID_PDU                         0x04
#define M2MB_BLE_ATT_PROTOCOL_ERROR_CODE_INSUFFICIENT_AUTHENTICATION         0x05
#define M2MB_BLE_ATT_PROTOCOL_ERROR_CODE_REQUEST_NOT_SUPPORTED               0x06
#define M2MB_BLE_ATT_PROTOCOL_ERROR_CODE_INVALID_OFFSET                      0x07
#define M2MB_BLE_ATT_PROTOCOL_ERROR_CODE_INSUFFICIENT_AUTHORIZATION          0x08
#define M2MB_BLE_ATT_PROTOCOL_ERROR_CODE_ATTRIBUTE_NOT_FOUND                 0x0A
#define M2MB_BLE_ATT_PROTOCOL_ERROR_CODE_ATTRIBUTE_NOT_LONG                  0x0B
#define M2MB_BLE_ATT_PROTOCOL_ERROR_CODE_INSUFFICIENT_ENCRYPTION_KEY_SIZE    0x0C
#define M2MB_BLE_ATT_PROTOCOL_ERROR_CODE_INVALID_ATTRIBUTE_VALUE_LENGTH      0x0D
#define M2MB_BLE_ATT_PROTOCOL_ERROR_CODE_INSUFFICIENT_ENCRYPTION             0x0F
#define M2MB_BLE_ATT_PROTOCOL_ERROR_CODE_UNSUPPORTED_GROUP_TYPE              0x10
#define M2MB_BLE_ATT_PROTOCOL_ERROR_CODE_INSUFFICIENT_RESOURCES              0x11
 
#define M2MB_BLE_GATT_CHARACTERISTIC_PROPERTIES_BROADCAST                      0x01
#define M2MB_BLE_GATT_CHARACTERISTIC_PROPERTIES_READ                           0x02
#define M2MB_BLE_GATT_CHARACTERISTIC_PROPERTIES_WRITE_WITHOUT_RESPONSE         0x04
#define M2MB_BLE_GATT_CHARACTERISTIC_PROPERTIES_WRITE                          0x08
#define M2MB_BLE_GATT_CHARACTERISTIC_PROPERTIES_NOTIFY                         0x10
#define M2MB_BLE_GATT_CHARACTERISTIC_PROPERTIES_INDICATE                       0x20
#define M2MB_BLE_GATT_CHARACTERISTIC_PROPERTIES_AUTHENTICATED_SIGNED_WRITES    0x40
#define M2MB_BLE_GATT_CHARACTERISTIC_PROPERTIES_EXTENDED_PROPERTIES            0x80
 
#define M2MB_BLE_GATT_CLIENT_CONFIGURATION_CHARACTERISTIC_NOTIFY_ENABLE        0x0001
#define M2MB_BLE_GATT_CLIENT_CONFIGURATION_CHARACTERISTIC_INDICATE_ENABLE      0x0002
 
#define M2MB_BLE_GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_BLUETOOTH_UUID_CONSTANT  {0x02, 0x29}
 
 
#define M2MB_BLE_DIS_PNP_ID_VENDOR_SOURCE_BLUETOOTH_SIG                 0x01
#define M2MB_BLE_DIS_PNP_ID_VENDOR_SOURCE_USB_IMPLEMENTORS_FORUM        0x02
 
/* Global typedefs ==============================================================================*/
 
typedef struct M2MB_BLE_UUID_16_S
{
    UINT8 UUID_Byte0;
    UINT8 UUID_Byte1;
} M2MB_BLE_UUID_16_T;
 
typedef struct M2MB_BLE_UUID_32_S
{
    UINT8 UUID_Byte0;
    UINT8 UUID_Byte1;
    UINT8 UUID_Byte2;
    UINT8 UUID_Byte3;
} M2MB_BLE_UUID_32_T;
 
typedef struct M2MB_BLE_UUID_128_S
{
    UINT8 UUID_Byte0;
    UINT8 UUID_Byte1;
    UINT8 UUID_Byte2;
    UINT8 UUID_Byte3;
    UINT8 UUID_Byte4;
    UINT8 UUID_Byte5;
    UINT8 UUID_Byte6;
    UINT8 UUID_Byte7;
    UINT8 UUID_Byte8;
    UINT8 UUID_Byte9;
    UINT8 UUID_Byte10;
    UINT8 UUID_Byte11;
    UINT8 UUID_Byte12;
    UINT8 UUID_Byte13;
    UINT8 UUID_Byte14;
    UINT8 UUID_Byte15;
} M2MB_BLE_UUID_128_T;
 
typedef enum
{
    UUID_TYPE_16_BIT_E, 
    UUID_TYPE_32_BIT_E, 
    UUID_TYPE_128_BIT_E, 
    UUID_INVALID_E,
} M2MB_BLE_UUID_TYPE_T;
 
typedef struct M2MB_BLE_UUID_S
{
    M2MB_BLE_UUID_TYPE_T uuid_type; 
    union
    {
        M2MB_BLE_UUID_16_T uuid_16; 
        M2MB_BLE_UUID_32_T uuid_32; 
        M2MB_BLE_UUID_128_T uuid_128; 
    };
} M2MB_BLE_UUID_T;
 
 
typedef enum
{
    M2MB_BLE_ADV_EVT_TYPE_UNDIRECTED = 0,    
    M2MB_BLE_ADV_EVT_TYPE_DIRECTED   = 1,    
    M2MB_BLE_ADV_EVT_TYPE_SCANNABLE  = 2,    
    M2MB_BLE_ADV_EVT_TYPE_NON_CONNECTABLE,   
    M2MB_BLE_ADV_EVT_TYPE_SCAN_RSP           
} M2MB_BLE_ADVERTISE_EVENT_TYPE_T;
 
typedef enum
{
    M2MB_BLE_NON_CONNECTABLE_E, 
    M2MB_BLE_CONNECTABLE_E, 
    M2MB_BLE_DIRECT_CONNECTABLE_E, 
} M2MB_BLE_CONNECTABILITY_MODE_T;
 
typedef enum
{
    M2MB_BLE_NON_DISCOVERABLE_MODE_E, 
    M2MB_BLE_LIMITED_DISCOVERABLE_MODE_E, 
    M2MB_BLE_GENERAL_DISCOVERABLE_MODE_E 
} M2MB_BLE_DISCOVERABILITY_MODE_T;
 
typedef enum
{
    M2MB_BLE_NON_PAIRABLEMODE_E, 
    M2MB_BLE_PAIRABLE_MODE_E, 
    M2MB_BLE_PAIRABLE_MODE_ENABLE_EXTENDED_EVENTS_E 
} M2MB_BLE_PAIRABILITY_MODE_T;
 
typedef enum
{
    M2MB_BLE_PERIPHERAL_ROLE_E, 
    M2MB_BLE_CENTRAL_ROLE_E, 
    M2MB_BLE_DUAL_ROLE_E, 
} M2MB_BLE_ROLE_T;
 
typedef enum
{
    M2MB_BLE_PUBLIC_E,
    
    M2MB_BLE_RANDOM_E,
    
    M2MB_BLE_RESOLVABLE_FALLBACK_PUBLIC_E,
    
    M2MB_BLE_RESOLVABLE_FALLBACK_PRIVATE_E,
    
    M2MB_BLE_ANONYMOUS_E
} M2MB_BLE_ADDRESS_TYPE_T;
 
 
typedef enum
{
   M2MB_BLE_DISPLAY_ONLY_E,
 
   M2MB_BLE_DISPLAY_YES_NO_E,
   
   M2MB_BLE_KEYBOARD_ONLY_E,
 
   M2MB_BLE_NO_INPUT_NO_OUTPUT_E,
 
   M2MB_BLE_KEYBOARD_DISPLAY_E
} M2MB_BLE_IO_CAPABILITY_T;
 
typedef struct  M2MB_BLE_BD_ADDR_S
{
    UINT8 BD_ADDR0;
    UINT8 BD_ADDR1;
    UINT8 BD_ADDR2;
    UINT8 BD_ADDR3;
    UINT8 BD_ADDR4;
    UINT8 BD_ADDR5;
} M2MB_BLE_BD_ADDR_T;
 
/* Use to hold MAX address in Hex format. Ex: 0xAABBCCDDEEFF*/
typedef INT8 M2MB_BLE_BOARDSTR_T[16];
 
typedef struct M2MB_BLE_BD_NAME_S
{
    UINT8 bd_name[M2MB_BLE_MAX_DEVICE_NAME_LENGTH];
} M2MB_BLE_BD_NAME_T;
 
typedef enum
{
    M2MB_BLE_DISABLE_INDICATION_NOTIFICATION_E, 
    M2MB_BLE_ENABLE_NOTIFICATION_E, 
    M2MB_BLE_ENABLE_INDICATION_E, 
} M2MB_BLE_CCCD_T;
 
 
/***************************************************************/
/*                  BLE Configuration / BLE Profile            */
/***************************************************************/
 
/* BLE configuration parameters */
typedef enum
{
    M2MB_BLE_CFG_GET_E, 
    M2MB_BLE_CFG_SET_E, 
    M2MB_BLE_CFG_SCAN_DURATION_GET_E,       
    M2MB_BLE_CFG_SCAN_DURATION_SET_E,       
    M2MB_BLE_CFG_SCAN_INTERVAL_GET_E,       
    M2MB_BLE_CFG_SCAN_INTERVAL_SET_E,       
    M2MB_BLE_CFG_SCAN_WINDOW_GET_E,         
    M2MB_BLE_CFG_SCAN_WINDOW_SET_E,         
    M2MB_BLE_CFG_SCAN_FILTER_POLICY_GET_E,  
    M2MB_BLE_CFG_SCAN_FILTER_POLICY_SET_E,  
    M2MB_BLE_CFG_SCAN_FILTER_DUPLICATES_GET_E, 
    M2MB_BLE_CFG_SCAN_FILTER_DUPLICATES_SET_E, 
    M2MB_BLE_CFG_ADV_INT_MIN_GET_E,         
    M2MB_BLE_CFG_ADV_INT_MIN_SET_E,         
    M2MB_BLE_CFG_ADV_INT_MAX_GET_E,         
    M2MB_BLE_CFG_ADV_INT_MAX_SET_E,         
    M2MB_BLE_CFG_ADV_DATA_GET_E,            
    M2MB_BLE_CFG_ADV_DATA_SET_E,            
    M2MB_BLE_CFG_SCAN_RSP_DATA_GET_E,       
    M2MB_BLE_CFG_SCAN_RSP_DATA_SET_E,       
    M2MB_BLE_CFG_CONNECT_MODE_GET_E,        
    M2MB_BLE_CFG_CONNECT_MODE_SET_E,        
    M2MB_BLE_CFG_DISCOVER_MODE_GET_E,       
    M2MB_BLE_CFG_DISCOVER_MODE_SET_E,       
    M2MB_BLE_CFG_PAIR_MODE_GET_E,           
    M2MB_BLE_CFG_PAIR_MODE_SET_E,           
    M2MB_BLE_CFG_CONNECTION_INT_MIN_GET_E,  
    M2MB_BLE_CFG_CONNECTION_INT_MIN_SET_E,  
    M2MB_BLE_CFG_CONNECTION_INT_MAX_GET_E,  
    M2MB_BLE_CFG_CONNECTION_INT_MAX_SET_E,  
    M2MB_BLE_CFG_SLAVE_LATENCY_GET_E,       
    M2MB_BLE_CFG_SLAVE_LATENCY_SET_E,       
    M2MB_BLE_CFG_SUPERVISION_TIMEOUT_GET_E, 
    M2MB_BLE_CFG_SUPERVISION_TIMEOUT_SET_E, 
    M2MB_BLE_CFG_IOCAPABILITY_GET_E,        
    M2MB_BLE_CFG_IOCAPABILITY_SET_E,        
    M2MB_BLE_CFG_MITM_GET_E,                
    M2MB_BLE_CFG_MITM_SET_E,                
    M2MB_BLE_CFG_FIXPIN_GET_E,              
    M2MB_BLE_CFG_FIXPIN_SET_E,              
    M2MB_BLE_CFG_LEPRIVACY_GET_E,           
    M2MB_BLE_CFG_LEPRIVACY_SET_E,           
    M2MB_BLE_CFG_BOND_STORE_SUPPORT_GET_E,  
    M2MB_BLE_CFG_BOND_STORE_SUPPORT_SET_E,  
    M2MB_BLE_CFG_BOND_SIZE_GET_E,           
    M2MB_BLE_CFG_BOND_SIZE_SET_E,           
    M2MB_BLE_CFG_PNP_VERSION_ID_GET_E,      
    M2MB_BLE_CFG_PNP_VERSION_ID_SET_E,      
    M2MB_BLE_CFG_PNP_VERSION_ID_SOURCE_GET_E,
    M2MB_BLE_CFG_PNP_VERSION_ID_SOURCE_SET_E,
    M2MB_BLE_CFG_PNP_PRODUCT_ID_GET_E,      
    M2MB_BLE_CFG_PNP_PRODUCT_ID_SET_E,      
    M2MB_BLE_CFG_PNP_PRODUCT_VERSION_GET_E, 
    M2MB_BLE_CFG_PNP_PRODUCT_VERSION_SET_E, 
    M2MB_BLE_CFG_BLE_ROLE_GET_E,            
    M2MB_BLE_CFG_BLE_ROLE_SET_E,            
    M2MB_BLE_CFG_BLE_BD_ADDR_GET_E,         
    M2MB_BLE_CFG_BLE_DEVICE_NAME_GET_E,     
    M2MB_BLE_CFG_BLE_DEVICE_NAME_SET_E,     
    M2MB_BLE_CFG_BLE_MANUFACTURER_NAME_GET_E,
    M2MB_BLE_CFG_BLE_MANUFACTURER_NAME_SET_E,
    M2MB_BLE_CFG_BLE_TIO_MODE_GET_E,        
    M2MB_BLE_CFG_BLE_TIO_MODE_SET_E,        
} M2MB_BLE_CONFIG_PARAM_T;
 
typedef struct M2MB_BLE_CENTRAL_CFG_S
{
    UINT16 scan_duration; 
    UINT16 scan_interval; 
    UINT16 scan_window; 
}M2MB_BLE_CENTRAL_CFG_T;
 
typedef struct M2MB_BLE_PERIPHERAL_CFG_S
{
    UINT16 advertise_interval_max; 
    UINT16 advertise_interval_min; 
    UINT8 advertise_data[M2MB_BLE_ADV_DATA_SIZE+1]; 
    UINT8 scan_response_data[M2MB_BLE_SCAN_RSP_DATA_SIZE+1]; 
    M2MB_BLE_CONNECTABILITY_MODE_T connect_mode; 
    M2MB_BLE_DISCOVERABILITY_MODE_T discover_mode; 
    M2MB_BLE_PAIRABILITY_MODE_T pair_mode; 
} M2MB_BLE_PERIPHERAL_CFG_T;
 
typedef struct M2MB_BLE_CONN_PARAM_S
{
    UINT16 connection_interval_max; 
    UINT16 connection_interval_min; 
    UINT16 slave_latency; 
    UINT16 supervision_timeout; 
} M2MB_BLE_CONN_PARAM_T;
 
typedef struct M2MB_BLE_SECURITY_CFG_S
{
    M2MB_BLE_IO_CAPABILITY_T iocapability; 
    UINT8 mitm; 
    UINT8 fix_pin[M2MB_BLE_FIXPIN_SIZE+1]; 
    UINT8 leprivacy; 
    UINT8 ble_bond_store_support; 
    UINT8 ble_bond_size; 
}M2MB_BLE_SECURITY_CFG_T;
 
typedef struct M2MB_BLE_DIS_INFO_S
{
    UINT16 pnpid_vendor_id; 
    UINT16 pnpid_vendor_id_source; 
    UINT16 pnpid_product_id; 
    UINT16 pnpid_product_version; 
}M2MB_BLE_DIS_INFO_T;
 
typedef struct M2MB_BLE_GENERAL_PARAM_S
{
    M2MB_BLE_ROLE_T ble_role; 
    M2MB_BLE_BD_ADDR_T ble_bd_address; 
    UINT16 ble_device_appearance; 
    INT8 ble_device_name[M2MB_BLE_MAX_DEVICE_NAME_LENGTH+1]; 
    INT8 ble_manufacturer_name[M2MB_BLE_MAX_MANUFACTURER_NAME_LENGTH+1]; 
    UINT8 ble_tio_mode; 
} M2MB_BLE_GENERAL_PARAM_T;
 
typedef struct M2MB_BLE_CGF_S
{
    M2MB_BLE_CENTRAL_CFG_T ble_central_cfg; 
    M2MB_BLE_PERIPHERAL_CFG_T ble_peripheral_cfg; 
    M2MB_BLE_CONN_PARAM_T ble_conn_param; 
    M2MB_BLE_SECURITY_CFG_T ble_security_cfg; 
    M2MB_BLE_DIS_INFO_T ble_dis_param; 
    M2MB_BLE_GENERAL_PARAM_T ble_gen_param; 
} M2MB_BLE_CGF_T;
 
 
/********************************************************************************************************/
/* BLE configuration related */
/********************************************************************************************************/
 
typedef enum
{
    M2MB_BLE_STATUS_SUCCESS_E,                      
    M2MB_BLE_STATUS_FAILURE_E,                      
    M2MB_BLE_STATUS_OUT_OF_RANGE_E,                 
    M2MB_BLE_STATUS_NOT_READY_E,                    
    M2MB_BLE_STATUS_UNSUPPORTED_E,                  
    M2MB_BLE_STATUS_PARAM_INVALID_E,                
    M2MB_BLE_STATUS_NO_MEM_E,                       
    M2MB_BLE_STATUS_AUTH_FAILURE_E,                 
    M2MB_BLE_STATUS_AUTH_REJECTED_E,                
    M2MB_BLE_STATUS_INVALID_E,                      
    M2MB_BLE_STATUS_ERR_INVALID_HANDLE_E,           
    M2MB_BLE_STATUS_ERR_READ_NOT_PERMITTED_E,       
    M2MB_BLE_STATUS_ERR_WRITE_NOT_PERMITTED_E,      
    M2MB_BLE_STATUS_ERR_INVALID_PDU_E,              
    M2MB_BLE_STATUS_ERR_REQUEST_NOT_SUPPORTED_E,    
    M2MB_BLE_STATUS_ERR_INVALID_OFFSET_E,           
    M2MB_BLE_STATUS_ERR_ATTRIBUTE_NOT_FOUND_E,      
    M2MB_BLE_STATUS_ERR_INVALID_ATTRIBUTE_VALUE_LENGTH_E,
    M2MB_BLE_STATUS_ERR_OUT_OF_ORDER_E,             
    M2MB_BLE_STATUS_ERR_INSUFFICIENT_AUTHORIZATION_E,
    M2MB_BLE_STATUS_ERR_INSUFFICIENT_AUTHENTICATION_E,
    M2MB_BLE_STATUS_ERR_INSUFFICIENT_ENCRYPTION_E,  
} M2MB_BLE_RESPONSE_T;
 
/* BLE EVENTS to the user / application layer from M2MB to registered callback */
typedef enum
{
    M2MB_BLE_PERIPHERAL_CONNECT_EVENT_E,                
    M2MB_BLE_PERIPHERAL_DISCONNECT_EVENT_E,             
    M2MB_BLE_PERIPHERAL_MTU_UPDATE_EVENT_E,             
    M2MB_BLE_GATT_SERVER_READ_REQUEST_EVENT_E,          
    M2MB_BLE_GATT_SERVER_WRITE_REQUEST_EVENT_E,         
    M2MB_BLE_GATT_SERVER_WRITE_WITHOUT_RESPONSE_EVENT_E,
    M2MB_BLE_GATT_SERVER_NOTIFICATION_ENABLE_EVENT_E,   
    M2MB_BLE_GATT_SERVER_INDICATION_ENABLE_EVENT_E,     
    M2MB_BLE_GATT_SERVER_NOTIFY_INDICATE_ENABLE_EVENT_E,
    M2MB_BLE_GATT_SERVER_NOTIFY_INDICATE_DISABLE_EVENT_E,
    M2MB_BLE_GATT_SERVER_NOTIFY_INDICATE_READ_EVENT_E,  
    M2MB_BLE_GATT_SERVER_CHAR_VALUE_UPDATED_EVENT_E,    /* This is covered by write events */
    
    M2MB_BLE_SCAN_EVENT_E,                              
    M2MB_BLE_CENTRAL_CONNECT_EVENT_E,                   
    M2MB_BLE_CENTRAL_DISCONNECT_EVENT_E,                
    M2MB_BLE_CENTRAL_MTU_UPDATE_EVENT_E,                
    M2MB_BLE_CENTRAL_NOTIFY_INDICATE_EVENT_E,           
    M2MB_BLE_CENTRAL_WRITE_EVENT_E,                     
    M2MB_BLE_CENTRAL_READ_EVENT_E,                      
    M2MB_BLE_CONNECT_PARAM_UPDATE_EVENT_E,              
    M2MB_BLE_SSP_PIN_NOTIFICATION_EVENT_E,              
    M2MB_BLE_SSP_PIN_EVENT_E,                           
    M2MB_BLE_SSP_CONF_EVENT_E,                          
    M2MB_BLE_PROVISIONING_SCAN_EVENT_E,                 
    M2MB_BLE_PROVISIONING_CONNECT_EVENT_E,              
} M2MB_BLE_USER_EVENTS_T;
 
/* When scan for BLE devices, send the list of scanned devices information in this format to the application */
/* 
** [TODO]: How to handle device name and advertise data at m2mb and app layer. Who allocates this memory and who frees this memory.
** Better solution is, in the register callback at app layer, memory is allocated. The scan event is posted over the message queue.
** Worker thread at application layer on the scan event over the queue handles / prints scan data and free the memory.
*/
typedef struct M2MB_BLE_SCAN_REPORT_DATA_S
{
    M2MB_BLE_BD_ADDR_T              BD_ADDR; 
    INT8                            RSSI; 
    INT8                            device_name[M2MB_BLE_MAX_DEVICE_NAME_LENGTH+1]; 
    M2MB_BLE_ADDRESS_TYPE_T         bd_addr_type; 
    M2MB_BLE_ADVERTISE_EVENT_TYPE_T bd_adv_type;  
    UINT8                           datalen; 
    UINT8                           data[M2MB_BLE_ADV_DATA_SIZE]; 
} M2MB_BLE_SCAN_REPORT_DATA_T;
 
#if 0
/* Connection param updates are specific to particular connection */
typedef struct M2MB_BLE_CONN_PARAM_UPADTE_S
{
    UINT8 connection_id;
    M2MB_BLE_CONN_PARAM_T connection_params;
} M2MB_BLE_CONN_PARAM_UPADTE_T;
 
 
/* Connection param updates are specific to particular connection */
typedef struct M2MB_BLE_MTU_UPADTE_S
{
    UINT8 connection_id;
    UINT32 mtu;
} M2MB_BLE_MTU_UPADTE_T;
#endif
 
/* structure to hold notification and indication data from remote GATT server */
typedef struct M2MB_BLE_CENTRAL_NOTIFY_INDICATE_DATA_S
{
    UINT8 connection_id; 
    UINT8 notify_ind_flag; 
    UINT16 handle; 
    UINT16 value_size; 
    UINT8 p_value[M2MB_BLE_MAX_ATTRIBUTE_LENGTH]; 
} M2MB_BLE_CENTRAL_NOTIFY_INDICATE_DATA_T;
 
typedef enum
{
    M2MB_BLE_SCAN_FILTER_DUPLICATE_DISABLE, 
    M2MB_BLE_SCAN_FILTER_DUPLICATE_ENABLE,  
} M2MB_BLE_CENTRAL_SCAN_FILTER_DUPLICATES_T;
 
typedef struct M2MB_BLE_GATT_SERVER_EVENT_DETAILS_S
{
    M2MB_BLE_RESPONSE_T *result_flag; 
    UINT32 service_id; 
    UINT32 char_id; 
    UINT32 char_cccd_id; 
    UINT8 **value; 
    UINT16 *value_length; /* value length. Pointer because, in case of read request value length should be filled and sent to m2mb layer */
    UINT8 cccd_val; 
    UINT8    more_data; 
    UINT32 offset; 
} M2MB_BLE_GATT_SERVER_EVENT_DETAILS_T;
 
typedef struct
{
    M2MB_BLE_BD_ADDR_T remote_bd_addr; 
    UINT32 pass_key; 
    UINT8 accept_flag; 
} M2MB_BLE_SSP_REQUEST_CTX_T;
 
typedef struct
{
    M2MB_BLE_BD_ADDR_T remote_bd_addr; 
    INT8 pincode[7]; 
    UINT8 pin_size; 
    UINT8 accept_flag; 
} M2MB_BLE_PIN_REQUEST_CTX_T;
 
typedef struct
{
    INT32 status; 
    INT32 attribute_handle; 
} M2MB_BLE_CLIENT_WRITE_RESP_CTX_T;
 
typedef struct
{
  INT32 status; 
  INT32 value_length; 
  INT8 *value; 
    INT32 attribute_handle;
} M2MB_BLE_CLIENT_READ_RESP_CTX_T;
 
/* This user context is sent to registered callback with user event type */
typedef struct M2MB_BLE_USER_EVENT_CTX_S
{
    UINT32 peripheral_connect_id; 
    UINT32 central_connect_id; 
    UINT32 mtu; 
    union M2MB_BLE_EVENT_DATA_U
    {
        M2MB_BLE_GATT_SERVER_EVENT_DETAILS_T gatt_attrib; 
        M2MB_BLE_SCAN_REPORT_DATA_T scan_data; 
        M2MB_BLE_CONN_PARAM_T connection_params; 
                M2MB_BLE_CENTRAL_NOTIFY_INDICATE_DATA_T notify_data; 
        M2MB_BLE_SSP_REQUEST_CTX_T ssp_conf; 
        M2MB_BLE_PIN_REQUEST_CTX_T ssp_pin; 
                M2MB_BLE_CLIENT_WRITE_RESP_CTX_T central_write; 
                M2MB_BLE_CLIENT_READ_RESP_CTX_T central_read; 
    }  event_data;
} M2MB_BLE_USER_EVENT_CTX_T;
 
 
 
 
/***************************************************************/
/*                      BLE Device Info                        */
/***************************************************************/
/*
  Device Info structure is maintained for handling the device information of connected peer devices (both in Central and Peripheral mode). So, this device info handling API's should be protected with a Mutex
  so that the device info will not be corrupted in case of simultaneous events that handles the device info part. 
  Ex: In central mode simultaneos operations are possible like, One device got connected and other device got disconnected at the same time.
 
  BLE Device info will hold all the information related to connected peer device.
  BLE Device info can be implemented as either array or linked list.
 
  Better to go with array with array size as (1 peripheral connection + max number of simultaneous connection supported by central).
  On successful connection the device info should be filled in the array, and on disconnect the device info should be deleted.
  
  In peripheral mode, when Central connects to the BLE device, few stacks do not provide connect ID. In this case try to have some special connection ID defined for peripheral connection.
  
*/
 
typedef struct M2MB_BLE_DEVICE_INFO_S
{
    BOOLEAN                     used_flag; 
    UINT32                      connection_id; 
    BOOLEAN                     remote_device_is_master; 
    M2MB_BLE_BD_ADDR_T          remote_address; 
    M2MB_BLE_ADDRESS_TYPE_T     remote_address_type; 
    M2MB_BLE_BD_ADDR_T          identity_address_bdaddr; 
    M2MB_BLE_ADDRESS_TYPE_T     identity_address_type; 
    UINT32                      mtu_size; 
    M2MB_BLE_CONN_PARAM_T       conn_params; 
    UINT8                       congested_flag; 
} M2MB_BLE_DEVICE_INFO_T;
 
 
/***************************************************************/
/*                      M2MB BLE API's                         */
/***************************************************************/
 
//typedef void   *HANDLE;
typedef HANDLE M2MB_BLE_HANDLE;
 
typedef struct M2MB_BLE_BOND_LIST_INFO_S
{
    M2MB_BLE_BD_ADDR_T      remote_bd_address; 
    M2MB_BLE_ADDRESS_TYPE_T remote_bd_address_type; 
    M2MB_BLE_ROLE_T         remote_bd_role;
} M2MB_BLE_BOND_LIST_INFO_T;
 
typedef enum
{
    M2MB_BLE_ADVERTISE_ON_WITH_CUSTOMIZED_ADV_DISABLE, 
    M2MB_BLE_ADVERTISE_ON_WITH_CUSTOMIZED_ADV_ENABLE, 
    M2MB_BLE_ADVERTISE_OFF, 
} M2MB_BLE_ADV_TYPE_T;
 
typedef enum
{
    M2MB_BLE_STATE_INITIALIZED, 
    M2MB_BLE_STATE_UNINITIALIZED, 
} M2MB_BLE_INIT_STATE_T;
 
typedef enum
{
    M2MB_BLE_GATT_PRIMARY_SERVICE_E, 
    M2MB_BLE_GATT_SECONDARY_SERVICE_E, 
    M2MB_BLE_GATT_INCLUDED_SERVICE_E, 
     M2MB_BLE_GATT_CHARACTERISTIC_E, 
    M2MB_BLE_GATT_DESCRIPTOR_E, 
} M2MB_BLE_GATT_ATTRIB_TYPE_T;
 
/* used for service discovery feature */
typedef struct M2MB_BLE_GATT_ELEMENT_S
{
    M2MB_BLE_GATT_ATTRIB_TYPE_T type; 
    M2MB_BLE_UUID_T uuid; 
    UINT16 attrib_handle; 
    UINT8 properties; 
    /* start and end hanldes are used only when type = M2MB_BLE_GATT_PRIMARY_SERVICE_E */
    UINT16 start_handle; 
    UINT16 end_handle; 
} M2MB_BLE_GATT_ELEMENT_T;
 
/* used for service discovery feature */
typedef struct M2MB_BLE_GATT_SRVD_S
{
    UINT16 elements_count; 
    M2MB_BLE_GATT_ELEMENT_T *gatt_elements; 
} M2MB_BLE_GATT_SRVD_T;
 
typedef void (*m2mb_ble_event_callback) (M2MB_BLE_HANDLE ble_handle, M2MB_BLE_USER_EVENTS_T ble_event, UINT16 resp_size, void *resp, void *userdata);
 
/* Global functions =============================================================================*/
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
M2MB_BLE_RESPONSE_T m2mb_ble_initialize(M2MB_BLE_HANDLE *ble_handle, m2mb_ble_event_callback ble_callback, void *user_data);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
M2MB_BLE_RESPONSE_T m2mb_ble_get_init_state(M2MB_BLE_HANDLE ble_handle, M2MB_BLE_INIT_STATE_T *state);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
M2MB_BLE_RESPONSE_T m2mb_ble_shutdown(M2MB_BLE_HANDLE ble_handle);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
M2MB_BLE_RESPONSE_T m2mb_ble_conf(M2MB_BLE_HANDLE ble_handle, UINT8 num_cmds, ...);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
M2MB_BLE_RESPONSE_T m2mb_ble_ssppin_reply(M2MB_BLE_HANDLE ble_handle, M2MB_BLE_BD_ADDR_T bd_addr, M2MB_BLE_ADDRESS_TYPE_T bd_addr_type, INT32 ssppin, UINT8 accept_flag);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
    
M2MB_BLE_RESPONSE_T m2mb_ble_sspconf_reply(M2MB_BLE_HANDLE ble_handle, M2MB_BLE_BD_ADDR_T bd_addr, M2MB_BLE_ADDRESS_TYPE_T bd_addr_type, UINT32 confirmation_flag);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
 
M2MB_BLE_RESPONSE_T m2mb_ble_bond_list_get(M2MB_BLE_HANDLE ble_handle, M2MB_BLE_BOND_LIST_INFO_T **bond_list_info, UINT32 *num_of_entries);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
 
M2MB_BLE_RESPONSE_T m2mb_ble_bond_delete(M2MB_BLE_HANDLE ble_handle, M2MB_BLE_BD_ADDR_T bd_addr);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
 
M2MB_BLE_RESPONSE_T m2mb_ble_advertise( M2MB_BLE_HANDLE ble_handle, M2MB_BLE_ADV_TYPE_T adv_type );
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
 
M2MB_BLE_RESPONSE_T m2mb_ble_gatts_service_add(M2MB_BLE_HANDLE ble_handle, M2MB_BLE_UUID_T service_uuid);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
 
M2MB_BLE_RESPONSE_T m2mb_ble_gatts_characteristic_add(M2MB_BLE_HANDLE ble_handle, UINT8 properties, M2MB_BLE_UUID_T characteristic_uuid);
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
M2MB_BLE_RESPONSE_T m2mb_ble_gatts_characteristic_value_add(M2MB_BLE_HANDLE ble_handle, UINT16 permissions, UINT16 value_len, UINT8 *value, UINT32 *characteristic_id);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
M2MB_BLE_RESPONSE_T m2mb_ble_gatts_complete(M2MB_BLE_HANDLE ble_handle, UINT32 *service_id);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
 
M2MB_BLE_RESPONSE_T m2mb_ble_gatts_serv_send_data(M2MB_BLE_HANDLE ble_handle, UINT32 serv_id, UINT32 char_id, UINT8 *value, UINT16 value_len, M2MB_BLE_CCCD_T cccd);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
M2MB_BLE_RESPONSE_T m2mb_ble_scan_start(M2MB_BLE_HANDLE ble_handle, M2MB_BLE_BD_ADDR_T bd_addr);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
 
M2MB_BLE_RESPONSE_T m2mb_ble_scan_stop(M2MB_BLE_HANDLE ble_handle);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
M2MB_BLE_RESPONSE_T m2mb_ble_connect(M2MB_BLE_HANDLE ble_handle, M2MB_BLE_BD_ADDR_T bd_addr, M2MB_BLE_ADDRESS_TYPE_T bd_addr_type, INT32 *connection_id);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
 
M2MB_BLE_RESPONSE_T m2mb_ble_disconnect(M2MB_BLE_HANDLE ble_handle, INT32 connection_id);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
 
M2MB_BLE_RESPONSE_T m2mb_ble_start_discovery(M2MB_BLE_HANDLE ble_handle, INT32 connection_id, M2MB_BLE_UUID_T uuid, M2MB_BLE_GATT_SRVD_T **results);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
 
M2MB_BLE_RESPONSE_T m2mb_ble_read_value_request(M2MB_BLE_HANDLE ble_handle, INT32 connection_id, INT32 char_handle, UINT8 **value, UINT16 *value_len);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
M2MB_BLE_RESPONSE_T m2mb_ble_write_value_request(M2MB_BLE_HANDLE ble_handle, INT32 connection_id, INT32 char_handle, UINT8 *value, UINT16 value_len);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
M2MB_BLE_RESPONSE_T m2mb_ble_write_value_command(M2MB_BLE_HANDLE ble_handle, INT32 connection_id, INT32 char_handle, UINT8 *value, UINT16 value_len);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
 
M2MB_BLE_RESPONSE_T m2mb_ble_cccd_request(M2MB_BLE_HANDLE ble_handle, INT32 connection_id, INT32 char_handle, M2MB_BLE_CCCD_T cccd_val);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
 
M2MB_BLE_RESPONSE_T m2mb_ble_device_bd_addr_get(M2MB_BLE_HANDLE ble_handle, M2MB_BLE_BD_ADDR_T *bd_addr);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
 
M2MB_BLE_RESPONSE_T m2mb_ble_provisioning_get( M2MB_BLE_HANDLE ble_handle, INT32 *status );
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
 
M2MB_BLE_RESPONSE_T m2mb_ble_provisioning_set( M2MB_BLE_HANDLE ble_handle, INT32 status );
 
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
 
M2MB_BLE_RESPONSE_T m2mb_ble_send_indication( M2MB_BLE_HANDLE ble_handle,  INT32 attribute_handle, INT32 conn_id, INT32 len, INT32 confirm, UINT8 *value);
 
/*****************************************************/
/******             Generic functions       **********/
/*****************************************************/
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
M2MB_BLE_RESPONSE_T m2mb_ble_connid_device_info_get(M2MB_BLE_HANDLE ble_handle, UINT8 conn_id, M2MB_BLE_DEVICE_INFO_T *dev_info);
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
 
 
M2MB_BLE_RESPONSE_T m2mb_ble_bdaddr_device_info_get(M2MB_BLE_HANDLE ble_handle, M2MB_BLE_BD_ADDR_T bd_addr, M2MB_BLE_DEVICE_INFO_T *dev_info);
 
M2MB_BLE_RESPONSE_T m2mb_ble_get_initialization_state(M2MB_BLE_HANDLE ble_handle, M2MB_BLE_INIT_STATE_T *state);
 
#endif