stack/srvc/srvc_dis.cc - platform/system/bt - Git at Google

 /******************************************************************************
  *
  *  Copyright (C) 1999-2013 Broadcom Corporation
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
  *  You may obtain a copy of the License at:
  *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  *
  ******************************************************************************/

 #define LOG_TAG "bt_srvc"

 #include "bt_target.h"
 #include "bt_utils.h"
 #include "btcore/include/uuid.h"
 #include "gatt_api.h"
 #include "gatt_int.h"
 #include "osi/include/log.h"
 #include "osi/include/osi.h"
 #include "srvc_dis_int.h"
 #include "srvc_eng_int.h"

 #define DIS_MAX_NUM_INC_SVR 0
 #define DIS_MAX_CHAR_NUM 9
 #define DIS_MAX_ATTR_NUM (DIS_MAX_CHAR_NUM * 2 + DIS_MAX_NUM_INC_SVR + 1)

 #ifndef DIS_ATTR_DB_SIZE
 #define DIS_ATTR_DB_SIZE \
   GATT_DB_MEM_SIZE(DIS_MAX_NUM_INC_SVR, DIS_MAX_CHAR_NUM, 0)
 #endif

 #define uint64_t_TO_STREAM(p, u64)   \
   {                                  \
     *(p)++ = (uint8_t)(u64);         \
     *(p)++ = (uint8_t)((u64) >> 8);  \
     *(p)++ = (uint8_t)((u64) >> 16); \
     *(p)++ = (uint8_t)((u64) >> 24); \
     *(p)++ = (uint8_t)((u64) >> 32); \
     *(p)++ = (uint8_t)((u64) >> 40); \
     *(p)++ = (uint8_t)((u64) >> 48); \
     *(p)++ = (uint8_t)((u64) >> 56); \
   }

 #define STREAM_TO_UINT64(u64, p)                                      \
   {                                                                   \
     (u64) = (((uint64_t)(*(p))) + ((((uint64_t)(*((p) + 1)))) << 8) + \
              ((((uint64_t)(*((p) + 2)))) << 16) +                     \
              ((((uint64_t)(*((p) + 3)))) << 24) +                     \
              ((((uint64_t)(*((p) + 4)))) << 32) +                     \
              ((((uint64_t)(*((p) + 5)))) << 40) +                     \
              ((((uint64_t)(*((p) + 6)))) << 48) +                     \
              ((((uint64_t)(*((p) + 7)))) << 56));                     \
     (p) += 8;                                                         \
   }

 static const uint16_t dis_attr_uuid[DIS_MAX_CHAR_NUM] = {
     GATT_UUID_SYSTEM_ID,
     GATT_UUID_MODEL_NUMBER_STR,
     GATT_UUID_SERIAL_NUMBER_STR,
     GATT_UUID_FW_VERSION_STR,
     GATT_UUID_HW_VERSION_STR,
     GATT_UUID_SW_VERSION_STR,
     GATT_UUID_MANU_NAME,
     GATT_UUID_IEEE_DATA,
     GATT_UUID_PNP_ID};

 tDIS_CB dis_cb;

 static tDIS_ATTR_MASK dis_uuid_to_attr(uint16_t uuid) {
   switch (uuid) {
     case GATT_UUID_SYSTEM_ID:
       return DIS_ATTR_SYS_ID_BIT;
     case GATT_UUID_MODEL_NUMBER_STR:
       return DIS_ATTR_MODEL_NUM_BIT;
     case GATT_UUID_SERIAL_NUMBER_STR:
       return DIS_ATTR_SERIAL_NUM_BIT;
     case GATT_UUID_FW_VERSION_STR:
       return DIS_ATTR_FW_NUM_BIT;
     case GATT_UUID_HW_VERSION_STR:
       return DIS_ATTR_HW_NUM_BIT;
     case GATT_UUID_SW_VERSION_STR:
       return DIS_ATTR_SW_NUM_BIT;
     case GATT_UUID_MANU_NAME:
       return DIS_ATTR_MANU_NAME_BIT;
     case GATT_UUID_IEEE_DATA:
       return DIS_ATTR_IEEE_DATA_BIT;
     case GATT_UUID_PNP_ID:
       return DIS_ATTR_PNP_ID_BIT;
     default:
       return 0;
   };
 }

 /*******************************************************************************
  *   dis_valid_handle_range
  *
  *   validate a handle to be a DIS attribute handle or not.
  ******************************************************************************/
 bool dis_valid_handle_range(uint16_t handle) {
   if (handle >= dis_cb.service_handle && handle <= dis_cb.max_handle)
     return true;
   else
     return false;
 }
 /*******************************************************************************
  *   dis_write_attr_value
  *
  *   Process write DIS attribute request.
  ******************************************************************************/
 uint8_t dis_write_attr_value(UNUSED_ATTR tGATT_WRITE_REQ* p_data,
                              tGATT_STATUS* p_status) {
   *p_status = GATT_WRITE_NOT_PERMIT;
   return SRVC_ACT_RSP;
 }
 /*******************************************************************************
  *   DIS Attributes Database Server Request callback
  ******************************************************************************/
 uint8_t dis_read_attr_value(UNUSED_ATTR uint8_t clcb_idx, uint16_t handle,
                             tGATT_VALUE* p_value, bool is_long,
                             tGATT_STATUS* p_status) {
   tDIS_DB_ENTRY* p_db_attr = dis_cb.dis_attr;
   uint8_t *p = p_value->value, i, *pp;
   uint16_t offset = p_value->offset;
   uint8_t act = SRVC_ACT_RSP;
   tGATT_STATUS st = GATT_NOT_FOUND;

   for (i = 0; i < DIS_MAX_CHAR_NUM; i++, p_db_attr++) {
     if (handle == p_db_attr->handle) {
       if ((p_db_attr->uuid == GATT_UUID_PNP_ID ||
            p_db_attr->uuid == GATT_UUID_SYSTEM_ID) &&
           is_long == true) {
         st = GATT_NOT_LONG;
         break;
       }
       st = GATT_SUCCESS;

       switch (p_db_attr->uuid) {
         case GATT_UUID_MANU_NAME:
         case GATT_UUID_MODEL_NUMBER_STR:
         case GATT_UUID_SERIAL_NUMBER_STR:
         case GATT_UUID_FW_VERSION_STR:
         case GATT_UUID_HW_VERSION_STR:
         case GATT_UUID_SW_VERSION_STR:
         case GATT_UUID_IEEE_DATA:
           pp = dis_cb.dis_value
                    .data_string[p_db_attr->uuid - GATT_UUID_MODEL_NUMBER_STR];
           if (pp != NULL) {
             if (strlen((char*)pp) > GATT_MAX_ATTR_LEN)
               p_value->len = GATT_MAX_ATTR_LEN;
             else
               p_value->len = (uint16_t)strlen((char*)pp);
           } else
             p_value->len = 0;

           if (offset > p_value->len) {
             st = GATT_INVALID_OFFSET;
             break;
           } else {
             p_value->len -= offset;
             pp += offset;
             ARRAY_TO_STREAM(p, pp, p_value->len);
             GATT_TRACE_EVENT("GATT_UUID_MANU_NAME len=0x%04x", p_value->len);
           }
           break;

         case GATT_UUID_SYSTEM_ID:
           uint64_t_TO_STREAM(p, dis_cb.dis_value.system_id); /* int_min */
           p_value->len = DIS_SYSTEM_ID_SIZE;
           break;

         case GATT_UUID_PNP_ID:
           UINT8_TO_STREAM(p, dis_cb.dis_value.pnp_id.vendor_id_src);
           UINT16_TO_STREAM(p, dis_cb.dis_value.pnp_id.vendor_id);
           UINT16_TO_STREAM(p, dis_cb.dis_value.pnp_id.product_id);
           UINT16_TO_STREAM(p, dis_cb.dis_value.pnp_id.product_version);
           p_value->len = DIS_PNP_ID_SIZE;
           break;
       }
       break;
     }
   }
   *p_status = st;
   return act;
 }

 /*******************************************************************************
  *
  * Function         dis_gatt_c_read_dis_value_cmpl
  *
  * Description      Client read DIS database complete callback.
  *
  * Returns          void
  *
  ******************************************************************************/
 static void dis_gatt_c_read_dis_value_cmpl(uint16_t conn_id) {
   tSRVC_CLCB* p_clcb = srvc_eng_find_clcb_by_conn_id(conn_id);

   dis_cb.dis_read_uuid_idx = 0xff;

   srvc_eng_release_channel(conn_id);

   if (dis_cb.p_read_dis_cback && p_clcb) {
     LOG_INFO(LOG_TAG, "%s conn_id:%d attr_mask = 0x%04x", __func__, conn_id,
              p_clcb->dis_value.attr_mask);

     (*dis_cb.p_read_dis_cback)(p_clcb->bda, &p_clcb->dis_value);
     dis_cb.p_read_dis_cback = NULL;
   }
 }

 /*******************************************************************************
  *
  * Function         dis_gatt_c_read_dis_req
  *
  * Description      Read remote device DIS attribute request.
  *
  * Returns          void
  *
  ******************************************************************************/
 bool dis_gatt_c_read_dis_req(uint16_t conn_id) {
   tGATT_READ_PARAM param;

   memset(&param, 0, sizeof(tGATT_READ_PARAM));

   param.service.uuid.len = LEN_UUID_16;
   param.service.s_handle = 1;
   param.service.e_handle = 0xFFFF;
   param.service.auth_req = 0;

   while (dis_cb.dis_read_uuid_idx < DIS_MAX_CHAR_NUM) {
     if (dis_uuid_to_attr(dis_attr_uuid[dis_cb.dis_read_uuid_idx]) &
         dis_cb.request_mask) {
       param.service.uuid.uu.uuid16 = dis_attr_uuid[dis_cb.dis_read_uuid_idx];

       if (GATTC_Read(conn_id, GATT_READ_BY_TYPE, &param) == GATT_SUCCESS)
         return true;

       GATT_TRACE_ERROR("Read DISInfo: 0x%04x GATT_Read Failed",
                        param.service.uuid.uu.uuid16);
     }

     dis_cb.dis_read_uuid_idx++;
   }

   dis_gatt_c_read_dis_value_cmpl(conn_id);

   return (false);
 }

 /*******************************************************************************
  *
  * Function         dis_c_cmpl_cback
  *
  * Description      Client operation complete callback.
  *
  * Returns          void
  *
  ******************************************************************************/
 void dis_c_cmpl_cback(tSRVC_CLCB* p_clcb, tGATTC_OPTYPE op, tGATT_STATUS status,
                       tGATT_CL_COMPLETE* p_data) {
   uint16_t read_type = dis_attr_uuid[dis_cb.dis_read_uuid_idx];
   uint8_t *pp = NULL, *p_str;
   uint16_t conn_id = p_clcb->conn_id;

   GATT_TRACE_EVENT(
       "dis_c_cmpl_cback() - op_code: 0x%02x  status: 0x%02x  \
                         read_type: 0x%04x",
       op, status, read_type);

   if (op != GATTC_OPTYPE_READ) return;

   if (p_data != NULL && status == GATT_SUCCESS) {
     pp = p_data->att_value.value;

     switch (read_type) {
       case GATT_UUID_SYSTEM_ID:
         GATT_TRACE_EVENT("DIS_ATTR_SYS_ID_BIT");
         if (p_data->att_value.len == DIS_SYSTEM_ID_SIZE) {
           p_clcb->dis_value.attr_mask |= DIS_ATTR_SYS_ID_BIT;
           /* save system ID*/
           STREAM_TO_UINT64(p_clcb->dis_value.system_id, pp);
         }
         break;

       case GATT_UUID_PNP_ID:
         if (p_data->att_value.len == DIS_PNP_ID_SIZE) {
           p_clcb->dis_value.attr_mask |= DIS_ATTR_PNP_ID_BIT;
           STREAM_TO_UINT8(p_clcb->dis_value.pnp_id.vendor_id_src, pp);
           STREAM_TO_UINT16(p_clcb->dis_value.pnp_id.vendor_id, pp);
           STREAM_TO_UINT16(p_clcb->dis_value.pnp_id.product_id, pp);
           STREAM_TO_UINT16(p_clcb->dis_value.pnp_id.product_version, pp);
         }
         break;

       case GATT_UUID_MODEL_NUMBER_STR:
       case GATT_UUID_SERIAL_NUMBER_STR:
       case GATT_UUID_FW_VERSION_STR:
       case GATT_UUID_HW_VERSION_STR:
       case GATT_UUID_SW_VERSION_STR:
       case GATT_UUID_MANU_NAME:
       case GATT_UUID_IEEE_DATA:
         p_str = p_clcb->dis_value
                     .data_string[read_type - GATT_UUID_MODEL_NUMBER_STR];
         osi_free(p_str);
         p_str = (uint8_t*)osi_malloc(p_data->att_value.len + 1);
         p_clcb->dis_value.attr_mask |= dis_uuid_to_attr(read_type);
         memcpy(p_str, p_data->att_value.value, p_data->att_value.len);
         p_str[p_data->att_value.len] = 0;
         p_clcb->dis_value.data_string[read_type - GATT_UUID_MODEL_NUMBER_STR] =
             p_str;
         break;

       default:
         break;

         break;
     } /* end switch */
   }   /* end if */

   dis_cb.dis_read_uuid_idx++;

   dis_gatt_c_read_dis_req(conn_id);
 }

 /*******************************************************************************
  *
  * Function         DIS_SrInit
  *
  * Description      Initialize the Device Information Service Server.
  *
  ******************************************************************************/
 tDIS_STATUS DIS_SrInit(tDIS_ATTR_MASK dis_attr_mask) {
   tGATT_STATUS status;

   if (dis_cb.enabled) {
     GATT_TRACE_ERROR("DIS already initalized");
     return DIS_SUCCESS;
   }

   memset(&dis_cb, 0, sizeof(tDIS_CB));

   btgatt_db_element_t service[DIS_MAX_ATTR_NUM] = {};

   bt_uuid_t svc_uuid;
   uuid_128_from_16(&svc_uuid, UUID_SERVCLASS_DEVICE_INFO);
   service[0].type = BTGATT_DB_PRIMARY_SERVICE;
   service[0].uuid = svc_uuid;

   for (int i = 0; dis_attr_mask != 0 && i < DIS_MAX_CHAR_NUM; i++) {
     dis_cb.dis_attr[i].uuid = dis_attr_uuid[i];

     bt_uuid_t char_uuid;
     uuid_128_from_16(&char_uuid, dis_cb.dis_attr[i].uuid);
     /* index 0 is service, so characteristics start from 1 */
     service[i + 1].type = BTGATT_DB_CHARACTERISTIC;
     service[i + 1].uuid = char_uuid;
     service[i + 1].properties = GATT_CHAR_PROP_BIT_READ;
     service[i + 1].permissions = GATT_PERM_READ;

     dis_attr_mask >>= 1;
   }

   /* Add a GAP service */
   status = GATTS_AddService(srvc_eng_cb.gatt_if, service,
                             sizeof(service) / sizeof(btgatt_db_element_t));
   if (status != GATT_SERVICE_STARTED) {
     GATT_TRACE_ERROR("Can not create service, DIS_Init failed!");
     return GATT_ERROR;
   }

   dis_cb.service_handle = service[0].attribute_handle;
   dis_cb.max_handle = dis_cb.service_handle + DIS_MAX_ATTR_NUM;

   for (int i = 0; i < DIS_MAX_CHAR_NUM; i++) {
     dis_cb.dis_attr[i].handle = service[i + 1].attribute_handle;

     GATT_TRACE_DEBUG("%s:  handle of new attribute 0x%04 = x%d", __func__,
                      dis_cb.dis_attr[i].uuid, dis_cb.dis_attr[i].handle);
   }

   dis_cb.enabled = true;
   return (tDIS_STATUS)status;
 }
 /*******************************************************************************
  *
  * Function         DIS_SrUpdate
  *
  * Description      Update the DIS server attribute values
  *
  ******************************************************************************/
 tDIS_STATUS DIS_SrUpdate(tDIS_ATTR_BIT dis_attr_bit, tDIS_ATTR* p_info) {
   uint8_t i = 1;
   tDIS_STATUS st = DIS_SUCCESS;

   if (dis_attr_bit & DIS_ATTR_SYS_ID_BIT) {
     dis_cb.dis_value.system_id = p_info->system_id;
   } else if (dis_attr_bit & DIS_ATTR_PNP_ID_BIT) {
     dis_cb.dis_value.pnp_id.vendor_id = p_info->pnp_id.vendor_id;
     dis_cb.dis_value.pnp_id.vendor_id_src = p_info->pnp_id.vendor_id_src;
     dis_cb.dis_value.pnp_id.product_id = p_info->pnp_id.product_id;
     dis_cb.dis_value.pnp_id.product_version = p_info->pnp_id.product_version;
   } else {
     st = DIS_ILLEGAL_PARAM;

     while (dis_attr_bit && i < (DIS_MAX_CHAR_NUM - 1)) {
       if (dis_attr_bit & (uint16_t)(1 << i)) {
         osi_free(dis_cb.dis_value.data_string[i - 1]);
         dis_cb.dis_value.data_string[i - 1] =
             (uint8_t*)osi_malloc(p_info->data_str.len + 1);
         memcpy(dis_cb.dis_value.data_string[i - 1], p_info->data_str.p_data,
                p_info->data_str.len);
         dis_cb.dis_value.data_string[i - 1][p_info->data_str.len] =
             0; /* make sure null terminate */
         st = DIS_SUCCESS;

         break;
       }
       i++;
     }
   }
   return st;
 }
 /*******************************************************************************
  *
  * Function         DIS_ReadDISInfo
  *
  * Description      Read remote device DIS information.
  *
  * Returns          void
  *
  ******************************************************************************/
 bool DIS_ReadDISInfo(BD_ADDR peer_bda, tDIS_READ_CBACK* p_cback,
                      tDIS_ATTR_MASK mask) {
   uint16_t conn_id;

   /* Initialize the DIS client if it hasn't been initialized already. */
   srvc_eng_init();

   /* For now we only handle one at a time */
   if (dis_cb.dis_read_uuid_idx != 0xff) return (false);

   if (p_cback == NULL) return (false);

   dis_cb.p_read_dis_cback = p_cback;
   /* Mark currently active operation */
   dis_cb.dis_read_uuid_idx = 0;

   dis_cb.request_mask = mask;

   GATT_TRACE_EVENT("DIS_ReadDISInfo() - BDA: %08x%04x  cl_read_uuid: 0x%04x",
                    (peer_bda[0] << 24) + (peer_bda[1] << 16) +
                        (peer_bda[2] << 8) + peer_bda[3],
                    (peer_bda[4] << 8) + peer_bda[5],
                    dis_attr_uuid[dis_cb.dis_read_uuid_idx]);

   GATT_GetConnIdIfConnected(srvc_eng_cb.gatt_if, peer_bda, &conn_id,
                             BT_TRANSPORT_LE);

   /* need to enhance it as multiple service is needed */
   srvc_eng_request_channel(peer_bda, SRVC_ID_DIS);

   if (conn_id == GATT_INVALID_CONN_ID) {
     return GATT_Connect(srvc_eng_cb.gatt_if, peer_bda, true, BT_TRANSPORT_LE,
                         false);
   }

   return dis_gatt_c_read_dis_req(conn_id);
 }
	/******************************************************************************
	*
	* Copyright (C) 1999-2013 Broadcom Corporation
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at:
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	******************************************************************************/

	#define LOG_TAG "bt_srvc"

	#include "bt_target.h"
	#include "bt_utils.h"
	#include "btcore/include/uuid.h"
	#include "gatt_api.h"
	#include "gatt_int.h"
	#include "osi/include/log.h"
	#include "osi/include/osi.h"
	#include "srvc_dis_int.h"
	#include "srvc_eng_int.h"

	#define DIS_MAX_NUM_INC_SVR 0
	#define DIS_MAX_CHAR_NUM 9
	#define DIS_MAX_ATTR_NUM (DIS_MAX_CHAR_NUM * 2 + DIS_MAX_NUM_INC_SVR + 1)

	#ifndef DIS_ATTR_DB_SIZE
	#define DIS_ATTR_DB_SIZE \
	GATT_DB_MEM_SIZE(DIS_MAX_NUM_INC_SVR, DIS_MAX_CHAR_NUM, 0)
	#endif

	#define uint64_t_TO_STREAM(p, u64) \
	{ \
	*(p)++ = (uint8_t)(u64); \
	*(p)++ = (uint8_t)((u64) >> 8); \
	*(p)++ = (uint8_t)((u64) >> 16); \
	*(p)++ = (uint8_t)((u64) >> 24); \
	*(p)++ = (uint8_t)((u64) >> 32); \
	*(p)++ = (uint8_t)((u64) >> 40); \
	*(p)++ = (uint8_t)((u64) >> 48); \
	*(p)++ = (uint8_t)((u64) >> 56); \
	}

	#define STREAM_TO_UINT64(u64, p) \
	{ \
	(u64) = (((uint64_t)((p))) + ((((uint64_t)(((p) + 1)))) << 8) + \
	((((uint64_t)(*((p) + 2)))) << 16) + \
	((((uint64_t)(*((p) + 3)))) << 24) + \
	((((uint64_t)(*((p) + 4)))) << 32) + \
	((((uint64_t)(*((p) + 5)))) << 40) + \
	((((uint64_t)(*((p) + 6)))) << 48) + \
	((((uint64_t)(*((p) + 7)))) << 56)); \
	(p) += 8; \
	}

	static const uint16_t dis_attr_uuid[DIS_MAX_CHAR_NUM] = {
	GATT_UUID_SYSTEM_ID,
	GATT_UUID_MODEL_NUMBER_STR,
	GATT_UUID_SERIAL_NUMBER_STR,
	GATT_UUID_FW_VERSION_STR,
	GATT_UUID_HW_VERSION_STR,
	GATT_UUID_SW_VERSION_STR,
	GATT_UUID_MANU_NAME,
	GATT_UUID_IEEE_DATA,
	GATT_UUID_PNP_ID};

	tDIS_CB dis_cb;

	static tDIS_ATTR_MASK dis_uuid_to_attr(uint16_t uuid) {
	switch (uuid) {
	case GATT_UUID_SYSTEM_ID:
	return DIS_ATTR_SYS_ID_BIT;
	case GATT_UUID_MODEL_NUMBER_STR:
	return DIS_ATTR_MODEL_NUM_BIT;
	case GATT_UUID_SERIAL_NUMBER_STR:
	return DIS_ATTR_SERIAL_NUM_BIT;
	case GATT_UUID_FW_VERSION_STR:
	return DIS_ATTR_FW_NUM_BIT;
	case GATT_UUID_HW_VERSION_STR:
	return DIS_ATTR_HW_NUM_BIT;
	case GATT_UUID_SW_VERSION_STR:
	return DIS_ATTR_SW_NUM_BIT;
	case GATT_UUID_MANU_NAME:
	return DIS_ATTR_MANU_NAME_BIT;
	case GATT_UUID_IEEE_DATA:
	return DIS_ATTR_IEEE_DATA_BIT;
	case GATT_UUID_PNP_ID:
	return DIS_ATTR_PNP_ID_BIT;
	default:
	return 0;
	};
	}

	/*******************************************************************************
	* dis_valid_handle_range
	*
	* validate a handle to be a DIS attribute handle or not.
	******************************************************************************/
	bool dis_valid_handle_range(uint16_t handle) {
	if (handle >= dis_cb.service_handle && handle <= dis_cb.max_handle)
	return true;
	else
	return false;
	}
	/*******************************************************************************
	* dis_write_attr_value
	*
	* Process write DIS attribute request.
	******************************************************************************/
	uint8_t dis_write_attr_value(UNUSED_ATTR tGATT_WRITE_REQ* p_data,
	tGATT_STATUS* p_status) {
	*p_status = GATT_WRITE_NOT_PERMIT;
	return SRVC_ACT_RSP;
	}
	/*******************************************************************************
	* DIS Attributes Database Server Request callback
	******************************************************************************/
	uint8_t dis_read_attr_value(UNUSED_ATTR uint8_t clcb_idx, uint16_t handle,
	tGATT_VALUE* p_value, bool is_long,
	tGATT_STATUS* p_status) {
	tDIS_DB_ENTRY* p_db_attr = dis_cb.dis_attr;
	uint8_t p = p_value->value, i, pp;
	uint16_t offset = p_value->offset;
	uint8_t act = SRVC_ACT_RSP;
	tGATT_STATUS st = GATT_NOT_FOUND;

	for (i = 0; i < DIS_MAX_CHAR_NUM; i++, p_db_attr++) {
	if (handle == p_db_attr->handle) {
	if ((p_db_attr->uuid == GATT_UUID_PNP_ID \|\|
	p_db_attr->uuid == GATT_UUID_SYSTEM_ID) &&
	is_long == true) {
	st = GATT_NOT_LONG;
	break;
	}
	st = GATT_SUCCESS;

	switch (p_db_attr->uuid) {
	case GATT_UUID_MANU_NAME:
	case GATT_UUID_MODEL_NUMBER_STR:
	case GATT_UUID_SERIAL_NUMBER_STR:
	case GATT_UUID_FW_VERSION_STR:
	case GATT_UUID_HW_VERSION_STR:
	case GATT_UUID_SW_VERSION_STR:
	case GATT_UUID_IEEE_DATA:
	pp = dis_cb.dis_value
	.data_string[p_db_attr->uuid - GATT_UUID_MODEL_NUMBER_STR];
	if (pp != NULL) {
	if (strlen((char*)pp) > GATT_MAX_ATTR_LEN)
	p_value->len = GATT_MAX_ATTR_LEN;
	else
	p_value->len = (uint16_t)strlen((char*)pp);
	} else
	p_value->len = 0;

	if (offset > p_value->len) {
	st = GATT_INVALID_OFFSET;
	break;
	} else {
	p_value->len -= offset;
	pp += offset;
	ARRAY_TO_STREAM(p, pp, p_value->len);
	GATT_TRACE_EVENT("GATT_UUID_MANU_NAME len=0x%04x", p_value->len);
	}
	break;

	case GATT_UUID_SYSTEM_ID:
	uint64_t_TO_STREAM(p, dis_cb.dis_value.system_id); /* int_min */
	p_value->len = DIS_SYSTEM_ID_SIZE;
	break;

	case GATT_UUID_PNP_ID:
	UINT8_TO_STREAM(p, dis_cb.dis_value.pnp_id.vendor_id_src);
	UINT16_TO_STREAM(p, dis_cb.dis_value.pnp_id.vendor_id);
	UINT16_TO_STREAM(p, dis_cb.dis_value.pnp_id.product_id);
	UINT16_TO_STREAM(p, dis_cb.dis_value.pnp_id.product_version);
	p_value->len = DIS_PNP_ID_SIZE;
	break;
	}
	break;
	}
	}
	*p_status = st;
	return act;
	}

	/*******************************************************************************
	*
	* Function dis_gatt_c_read_dis_value_cmpl
	*
	* Description Client read DIS database complete callback.
	*
	* Returns void
	*
	******************************************************************************/
	static void dis_gatt_c_read_dis_value_cmpl(uint16_t conn_id) {
	tSRVC_CLCB* p_clcb = srvc_eng_find_clcb_by_conn_id(conn_id);

	dis_cb.dis_read_uuid_idx = 0xff;

	srvc_eng_release_channel(conn_id);

	if (dis_cb.p_read_dis_cback && p_clcb) {
	LOG_INFO(LOG_TAG, "%s conn_id:%d attr_mask = 0x%04x", __func__, conn_id,
	p_clcb->dis_value.attr_mask);

	(*dis_cb.p_read_dis_cback)(p_clcb->bda, &p_clcb->dis_value);
	dis_cb.p_read_dis_cback = NULL;
	}
	}

	/*******************************************************************************
	*
	* Function dis_gatt_c_read_dis_req
	*
	* Description Read remote device DIS attribute request.
	*
	* Returns void
	*
	******************************************************************************/
	bool dis_gatt_c_read_dis_req(uint16_t conn_id) {
	tGATT_READ_PARAM param;

	memset(&param, 0, sizeof(tGATT_READ_PARAM));

	param.service.uuid.len = LEN_UUID_16;
	param.service.s_handle = 1;
	param.service.e_handle = 0xFFFF;
	param.service.auth_req = 0;

	while (dis_cb.dis_read_uuid_idx < DIS_MAX_CHAR_NUM) {
	if (dis_uuid_to_attr(dis_attr_uuid[dis_cb.dis_read_uuid_idx]) &
	dis_cb.request_mask) {
	param.service.uuid.uu.uuid16 = dis_attr_uuid[dis_cb.dis_read_uuid_idx];

	if (GATTC_Read(conn_id, GATT_READ_BY_TYPE, &param) == GATT_SUCCESS)
	return true;

	GATT_TRACE_ERROR("Read DISInfo: 0x%04x GATT_Read Failed",
	param.service.uuid.uu.uuid16);
	}

	dis_cb.dis_read_uuid_idx++;
	}

	dis_gatt_c_read_dis_value_cmpl(conn_id);

	return (false);
	}

	/*******************************************************************************
	*
	* Function dis_c_cmpl_cback
	*
	* Description Client operation complete callback.
	*
	* Returns void
	*
	******************************************************************************/
	void dis_c_cmpl_cback(tSRVC_CLCB* p_clcb, tGATTC_OPTYPE op, tGATT_STATUS status,
	tGATT_CL_COMPLETE* p_data) {
	uint16_t read_type = dis_attr_uuid[dis_cb.dis_read_uuid_idx];
	uint8_t pp = NULL, p_str;
	uint16_t conn_id = p_clcb->conn_id;

	GATT_TRACE_EVENT(
	"dis_c_cmpl_cback() - op_code: 0x%02x status: 0x%02x \
	read_type: 0x%04x",
	op, status, read_type);

	if (op != GATTC_OPTYPE_READ) return;

	if (p_data != NULL && status == GATT_SUCCESS) {
	pp = p_data->att_value.value;

	switch (read_type) {
	case GATT_UUID_SYSTEM_ID:
	GATT_TRACE_EVENT("DIS_ATTR_SYS_ID_BIT");
	if (p_data->att_value.len == DIS_SYSTEM_ID_SIZE) {
	p_clcb->dis_value.attr_mask \|= DIS_ATTR_SYS_ID_BIT;
	/* save system ID*/
	STREAM_TO_UINT64(p_clcb->dis_value.system_id, pp);
	}
	break;

	case GATT_UUID_PNP_ID:
	if (p_data->att_value.len == DIS_PNP_ID_SIZE) {
	p_clcb->dis_value.attr_mask \|= DIS_ATTR_PNP_ID_BIT;
	STREAM_TO_UINT8(p_clcb->dis_value.pnp_id.vendor_id_src, pp);
	STREAM_TO_UINT16(p_clcb->dis_value.pnp_id.vendor_id, pp);
	STREAM_TO_UINT16(p_clcb->dis_value.pnp_id.product_id, pp);
	STREAM_TO_UINT16(p_clcb->dis_value.pnp_id.product_version, pp);
	}
	break;

	case GATT_UUID_MODEL_NUMBER_STR:
	case GATT_UUID_SERIAL_NUMBER_STR:
	case GATT_UUID_FW_VERSION_STR:
	case GATT_UUID_HW_VERSION_STR:
	case GATT_UUID_SW_VERSION_STR:
	case GATT_UUID_MANU_NAME:
	case GATT_UUID_IEEE_DATA:
	p_str = p_clcb->dis_value
	.data_string[read_type - GATT_UUID_MODEL_NUMBER_STR];
	osi_free(p_str);
	p_str = (uint8_t*)osi_malloc(p_data->att_value.len + 1);
	p_clcb->dis_value.attr_mask \|= dis_uuid_to_attr(read_type);
	memcpy(p_str, p_data->att_value.value, p_data->att_value.len);
	p_str[p_data->att_value.len] = 0;
	p_clcb->dis_value.data_string[read_type - GATT_UUID_MODEL_NUMBER_STR] =
	p_str;
	break;

	default:
	break;

	break;
	} /* end switch */
	} /* end if */

	dis_cb.dis_read_uuid_idx++;

	dis_gatt_c_read_dis_req(conn_id);
	}

	/*******************************************************************************
	*
	* Function DIS_SrInit
	*
	* Description Initialize the Device Information Service Server.
	*
	******************************************************************************/
	tDIS_STATUS DIS_SrInit(tDIS_ATTR_MASK dis_attr_mask) {
	tGATT_STATUS status;

	if (dis_cb.enabled) {
	GATT_TRACE_ERROR("DIS already initalized");
	return DIS_SUCCESS;
	}

	memset(&dis_cb, 0, sizeof(tDIS_CB));

	btgatt_db_element_t service[DIS_MAX_ATTR_NUM] = {};

	bt_uuid_t svc_uuid;
	uuid_128_from_16(&svc_uuid, UUID_SERVCLASS_DEVICE_INFO);
	service[0].type = BTGATT_DB_PRIMARY_SERVICE;
	service[0].uuid = svc_uuid;

	for (int i = 0; dis_attr_mask != 0 && i < DIS_MAX_CHAR_NUM; i++) {
	dis_cb.dis_attr[i].uuid = dis_attr_uuid[i];

	bt_uuid_t char_uuid;
	uuid_128_from_16(&char_uuid, dis_cb.dis_attr[i].uuid);
	/* index 0 is service, so characteristics start from 1 */
	service[i + 1].type = BTGATT_DB_CHARACTERISTIC;
	service[i + 1].uuid = char_uuid;
	service[i + 1].properties = GATT_CHAR_PROP_BIT_READ;
	service[i + 1].permissions = GATT_PERM_READ;

	dis_attr_mask >>= 1;
	}

	/* Add a GAP service */
	status = GATTS_AddService(srvc_eng_cb.gatt_if, service,
	sizeof(service) / sizeof(btgatt_db_element_t));
	if (status != GATT_SERVICE_STARTED) {
	GATT_TRACE_ERROR("Can not create service, DIS_Init failed!");
	return GATT_ERROR;
	}

	dis_cb.service_handle = service[0].attribute_handle;
	dis_cb.max_handle = dis_cb.service_handle + DIS_MAX_ATTR_NUM;

	for (int i = 0; i < DIS_MAX_CHAR_NUM; i++) {
	dis_cb.dis_attr[i].handle = service[i + 1].attribute_handle;

	GATT_TRACE_DEBUG("%s: handle of new attribute 0x%04 = x%d", __func__,
	dis_cb.dis_attr[i].uuid, dis_cb.dis_attr[i].handle);
	}

	dis_cb.enabled = true;
	return (tDIS_STATUS)status;
	}
	/*******************************************************************************
	*
	* Function DIS_SrUpdate
	*
	* Description Update the DIS server attribute values
	*
	******************************************************************************/
	tDIS_STATUS DIS_SrUpdate(tDIS_ATTR_BIT dis_attr_bit, tDIS_ATTR* p_info) {
	uint8_t i = 1;
	tDIS_STATUS st = DIS_SUCCESS;

	if (dis_attr_bit & DIS_ATTR_SYS_ID_BIT) {
	dis_cb.dis_value.system_id = p_info->system_id;
	} else if (dis_attr_bit & DIS_ATTR_PNP_ID_BIT) {
	dis_cb.dis_value.pnp_id.vendor_id = p_info->pnp_id.vendor_id;
	dis_cb.dis_value.pnp_id.vendor_id_src = p_info->pnp_id.vendor_id_src;
	dis_cb.dis_value.pnp_id.product_id = p_info->pnp_id.product_id;
	dis_cb.dis_value.pnp_id.product_version = p_info->pnp_id.product_version;
	} else {
	st = DIS_ILLEGAL_PARAM;

	while (dis_attr_bit && i < (DIS_MAX_CHAR_NUM - 1)) {
	if (dis_attr_bit & (uint16_t)(1 << i)) {
	osi_free(dis_cb.dis_value.data_string[i - 1]);
	dis_cb.dis_value.data_string[i - 1] =
	(uint8_t*)osi_malloc(p_info->data_str.len + 1);
	memcpy(dis_cb.dis_value.data_string[i - 1], p_info->data_str.p_data,
	p_info->data_str.len);
	dis_cb.dis_value.data_string[i - 1][p_info->data_str.len] =
	0; /* make sure null terminate */
	st = DIS_SUCCESS;

	break;
	}
	i++;
	}
	}
	return st;
	}
	/*******************************************************************************
	*
	* Function DIS_ReadDISInfo
	*
	* Description Read remote device DIS information.
	*
	* Returns void
	*
	******************************************************************************/
	bool DIS_ReadDISInfo(BD_ADDR peer_bda, tDIS_READ_CBACK* p_cback,
	tDIS_ATTR_MASK mask) {
	uint16_t conn_id;

	/* Initialize the DIS client if it hasn't been initialized already. */
	srvc_eng_init();

	/* For now we only handle one at a time */
	if (dis_cb.dis_read_uuid_idx != 0xff) return (false);

	if (p_cback == NULL) return (false);

	dis_cb.p_read_dis_cback = p_cback;
	/* Mark currently active operation */
	dis_cb.dis_read_uuid_idx = 0;

	dis_cb.request_mask = mask;

	GATT_TRACE_EVENT("DIS_ReadDISInfo() - BDA: %08x%04x cl_read_uuid: 0x%04x",
	(peer_bda[0] << 24) + (peer_bda[1] << 16) +
	(peer_bda[2] << 8) + peer_bda[3],
	(peer_bda[4] << 8) + peer_bda[5],
	dis_attr_uuid[dis_cb.dis_read_uuid_idx]);

	GATT_GetConnIdIfConnected(srvc_eng_cb.gatt_if, peer_bda, &conn_id,
	BT_TRANSPORT_LE);

	/* need to enhance it as multiple service is needed */
	srvc_eng_request_channel(peer_bda, SRVC_ID_DIS);

	if (conn_id == GATT_INVALID_CONN_ID) {
	return GATT_Connect(srvc_eng_cb.gatt_if, peer_bda, true, BT_TRANSPORT_LE,
	false);
	}

	return dis_gatt_c_read_dis_req(conn_id);
	}