ble_gatt.h

Go to the documentation of this file.

/****************************************************************************
 * modules/include/bluetooth/ble_gatt.h
 *
 *   Copyright 2018 Sony Semiconductor Solutions Corporation
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of Sony Semiconductor Solutions Corporation nor
 *    the names of its contributors may be used to endorse or promote
 *    products derived from this software without specific prior written
 *    permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 ****************************************************************************/
 
#ifndef __MODULES_INCLUDE_BLUETOOTH_BLE_GATT_H
#define __MODULES_INCLUDE_BLUETOOTH_BLE_GATT_H
 
/****************************************************************************
 * Included Files
 ****************************************************************************/
 
#include <stdint.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/bt_common.h>
 
/****************************************************************************
 * Pre-processor Definitions
 ****************************************************************************/
 
#define BLE_MAX_SERVICES 1
#define BLE_MAX_CHARACTERISTICS 1
#define BLE_MAX_CHAR_SIZE 20
#define BLE_GATT_INVALID_SERVICE_HANDLE UINT16_MAX
#define BLE_GATT_INVALID_ATTRIBUTE_HANDLE (0x0000)
 
#define BLE_DB_DISCOVERY_MAX_SRV          3
#define BLE_DB_DISCOVERY_MAX_CHAR_PER_SRV 4
/****************************************************************************
 * Public Types prototype
 ****************************************************************************/
 
struct ble_gatt_char_s;
 
/****************************************************************************
 * Public Types
 ****************************************************************************/
 
typedef enum
{
  BLE_UUID_TYPE_UUID128 = 0,         
  BLE_UUID_TYPE_BASEALIAS_BTSIG,     
  BLE_UUID_TYPE_BASEALIAS_VENDOR,    
} BLE_GATT_UUID_TYPE;
 
typedef enum
{
  BLE_GATTS_SRVTYP_PRIMARY = 1, 
  BLE_GATTS_SRVTYP_SECONDARY,   
} BLE_GATT_TYPE;
 
typedef enum{
  BLE_SEC_MODE_NO_ACCESS  = 0x00,    
  BLE_SEC_MODE1LV1_NO_SEC,           
  BLE_SEC_MODE1LV2_NO_MITM_ENC,      
  BLE_SEC_MODE1LV3_MITM_ENC,         
  BLE_SEC_MODE2LV1_NO_MITM_DATA_SGN, 
  BLE_SEC_MODE2LV2__MITM_DATA_SGN,   
} BLE_SEC_MODE;
 
typedef struct
{
  uint8_t uuid128[BT_UUID128_LEN]; 
} BLE_UUID128;
 
typedef struct
{
  BLE_UUID128 uuidBase;  
  uint16_t    uuidAlias; 
} BLE_UUID_ALIAS;
 
typedef struct
{
  BLE_GATT_UUID_TYPE  type;      
  union
  {
    BLE_UUID128       uuid128;   
    BLE_UUID_ALIAS    alias;     
  }                   value;     
} BLE_UUID;
 
typedef struct
{
  BLE_SEC_MODE  readPerm; 
  BLE_SEC_MODE writePerm; 
} BLE_ATTR_PERM;
 
typedef struct
{
  BLE_ATTR_PERM             attrPerm; 
  uint8_t                   *data;    
  uint16_t                  length;   
} BLE_CHAR_VALUE;
 
typedef struct
{
  uint8_t broadcast       :1; 
  uint8_t read            :1; 
  uint8_t writeWoResp     :1; 
  uint8_t write           :1; 
  uint8_t notify          :1; 
  uint8_t indicate        :1; 
  uint8_t authSignedWr    :1; 
  uint8_t reserve         :1; 
} BLE_CHAR_PROP;
 
struct ble_gatt_peripheral_ops_s
{
  void (*write)(struct ble_gatt_char_s *ble_gatt_char);               
  void (*read)(struct ble_gatt_char_s *ble_gatt_char);                
  void (*notify)(struct ble_gatt_char_s *ble_gatt_char, bool enable); 
};
 
struct ble_gatt_char_s
{
  uint16_t              handle;        
  BLE_UUID              uuid;          
  BLE_CHAR_VALUE        value;         
  BLE_CHAR_PROP         property;      
  uint8_t               status;        
  union
  {
    struct ble_gatt_central_ops_s    *ble_gatt_central_ops;    
    struct ble_gatt_peripheral_ops_s *ble_gatt_peripheral_ops; 
  };
};
 
struct ble_gatt_service_s
{
  uint16_t               handle;                          
  BLE_UUID               uuid;                            
  BLE_GATT_TYPE          type;                            
  uint8_t                num;                             
  struct ble_gatt_char_s *chars[BLE_MAX_CHARACTERISTICS]; 
};
 
struct ble_gatt_state_s
{
  struct ble_state_s        *ble_state;                 
  struct ble_hal_gatt_ops_s *ble_hal_gatt_ops;          
  uint8_t                   num;                        
  struct ble_gatt_service_s services[BLE_MAX_SERVICES]; 
  /* TODO: temporary, needs to consider the design */
  struct ble_gatt_central_ops_s *ble_gatt_central_ops;  
};
 
struct ble_gattc_handle_range_s
{
  uint16_t start_handle; 
  uint16_t end_handle;   
};
 
struct ble_gattc_char_s
{
  BLE_CHAR_PROP char_prope;      
  uint16_t      char_valhandle;  
  uint16_t      char_declhandle; 
  BLE_UUID      char_valuuid;    
};
 
struct ble_gattc_db_disc_char_s
{
  uint16_t                cepd_handle;
 
  uint16_t                cudd_handle;
 
  uint16_t                cccd_handle;
 
  uint16_t                sccd_handle;
 
  uint16_t                cpfd_handle;
 
  uint16_t                cafd_handle;
 
  struct ble_gattc_char_s characteristic;
};
 
struct ble_gattc_db_disc_srv_s
{
  uint8_t                         char_count;                                         
  struct ble_gattc_handle_range_s srv_handle_range;                                   
  struct ble_gattc_db_disc_char_s characteristics[BLE_DB_DISCOVERY_MAX_CHAR_PER_SRV]; 
  BLE_UUID                        srv_uuid;                                           
};
 
struct ble_gattc_db_discovery_s
{
  uint8_t                        srv_count;                           
  uint16_t                       conn_handle;                         
  struct ble_gattc_db_disc_srv_s services[BLE_DB_DISCOVERY_MAX_SRV];  
};
 
struct ble_gatt_coverrun_state_s
{
  uint8_t  srv_count;  
  uint16_t end_handle; 
};
 
struct ble_gatt_event_db_discovery_t
{
  uint8_t                           group_id;     
  uint8_t                           event_id;     
  uint8_t                           result;       
  uint16_t                          conn_handle;  
  struct ble_gatt_coverrun_state_s  state;        
  union{
    uint32_t                        reason;       
    struct ble_gattc_db_discovery_s db_discovery; 
  } params;                                       
};
 
struct ble_gatt_central_ops_s
{
  void (*write)(uint16_t conn_handle, struct ble_gatt_char_s *ble_gatt_char);
 
  void (*read)(uint16_t conn_handle, struct ble_gatt_char_s *ble_gatt_char);
 
  void (*notify)(uint16_t conn_handle, struct ble_gatt_char_s *ble_gatt_char);
 
  void (*database_discovery)(struct ble_gatt_event_db_discovery_t *db_disc);
 
  void (*descriptor_write)(uint16_t conn_handle, uint16_t handle, int status);
 
  void (*descriptor_read)(uint16_t conn_handle,
                          uint16_t handle,
                          uint8_t  *data,
                          uint16_t len);
};
 
#ifdef __cplusplus
#define EXTERN extern "C"
extern "C"
{
#else
#define EXTERN extern
#endif
 
/****************************************************************************
 * Public Function Prototypes
 ****************************************************************************/
 
bool ble_gatt_is_supported(void);
 
int ble_create_service(struct ble_gatt_service_s **service);
 
int ble_register_servce(struct ble_gatt_service_s *service);
 
int ble_add_characteristic(struct ble_gatt_service_s *service, struct ble_gatt_char_s *charc);
 
int ble_characteristic_notify(uint16_t               conn_handle,
                              struct ble_gatt_char_s *charc,
                              uint8_t                *data,
                              int                    len);
 
int ble_characteristic_read(uint16_t conn_handle, struct ble_gatt_char_s *charc);
 
int ble_characteristic_write(uint16_t               conn_handle,
                             struct ble_gatt_char_s *charc,
                             uint8_t                *data,
                             int                    len);
 
int ble_read_characteristic(uint16_t conn_handle, uint16_t char_handle);
 
int ble_write_characteristic(uint16_t conn_handle,
                             uint16_t char_handle,
                             uint8_t  *data,
                             int      len,
                             bool     rsp);
 
int ble_descriptor_read(uint16_t conn_handle, uint16_t handle);
 
int ble_descriptor_write(uint16_t conn_handle,
                         uint16_t handle,
                         uint8_t  *data,
                         int      len);
 
int ble_start_db_discovery(uint16_t conn_handle);
 
int ble_continue_db_discovery(uint16_t start_handle, uint16_t conn_handle);
 
int ble_discover_uuid(uint16_t conn_handle, BLE_UUID *srv_uuid, BLE_UUID *char_uuid);
 
int ble_set_vendor_uuid(BLE_UUID *uuid);
 
#undef EXTERN
#ifdef __cplusplus
}
#endif
 
#endif /* __MODULES_INCLUDE_BLUETOOTH_BLE_GATT_H */