OVMS3-idf/components/bt/bluedroid/stack/gatt/gatt_utils.c
island 2955b20f2e bt component: fix bluetooth gatt packets process bugs
1. Add process of prepare write request packets
2. Add process of execute write request packets
3. Add process of reliable write request packets
4. Fix bug of processing read blob request packets
5. Fix bug of processing write request packets
6. Optimize error check and process in stack
2017-03-06 17:20:45 +08:00

2663 lines
83 KiB
C

/******************************************************************************
*
* Copyright (C) 2009-2012 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.
*
******************************************************************************/
/******************************************************************************
*
* this file contains GATT utility functions
*
******************************************************************************/
#include "bt_target.h"
//#include "bt_utils.h"
#if BLE_INCLUDED == TRUE
#include <string.h>
#include <stdio.h>
#include "gki.h"
#include "l2cdefs.h"
#include "gatt_int.h"
#include "gatt_api.h"
#include "gattdefs.h"
#include "sdp_api.h"
#include "btm_int.h"
/* check if [x, y] and [a, b] have overlapping range */
#define GATT_VALIDATE_HANDLE_RANGE(x, y, a, b) (y >= a && x <= b)
#define GATT_GET_NEXT_VALID_HANDLE(x) (((x)/10 + 1) * 10)
const char *const op_code_name[] = {
"UNKNOWN",
"ATT_RSP_ERROR",
"ATT_REQ_MTU",
"ATT_RSP_MTU",
"ATT_REQ_READ_INFO",
"ATT_RSP_READ_INFO",
"ATT_REQ_FIND_TYPE_VALUE",
"ATT_RSP_FIND_TYPE_VALUE",
"ATT_REQ_READ_BY_TYPE",
"ATT_RSP_READ_BY_TYPE",
"ATT_REQ_READ",
"ATT_RSP_READ",
"ATT_REQ_READ_BLOB",
"ATT_RSP_READ_BLOB",
"GATT_REQ_READ_MULTI",
"GATT_RSP_READ_MULTI",
"GATT_REQ_READ_BY_GRP_TYPE",
"GATT_RSP_READ_BY_GRP_TYPE",
"ATT_REQ_WRITE",
"ATT_RSP_WRITE",
"ATT_CMD_WRITE",
"ATT_SIGN_CMD_WRITE",
"ATT_REQ_PREPARE_WRITE",
"ATT_RSP_PREPARE_WRITE",
"ATT_REQ_EXEC_WRITE",
"ATT_RSP_EXEC_WRITE",
"Reserved",
"ATT_HANDLE_VALUE_NOTIF",
"Reserved",
"ATT_HANDLE_VALUE_IND",
"ATT_HANDLE_VALUE_CONF",
"ATT_OP_CODE_MAX"
};
static const UINT8 base_uuid[LEN_UUID_128] = {0xFB, 0x34, 0x9B, 0x5F, 0x80, 0x00, 0x00, 0x80,
0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/*******************************************************************************
**
** Function gatt_free_pending_ind
**
** Description Free all pending indications
**
** Returns None
**
*******************************************************************************/
void gatt_free_pending_ind(tGATT_TCB *p_tcb)
{
GATT_TRACE_DEBUG("gatt_free_pending_ind");
/* release all queued indications */
while (!GKI_queue_is_empty(&p_tcb->pending_ind_q)) {
GKI_freebuf (GKI_dequeue (&p_tcb->pending_ind_q));
}
}
/*******************************************************************************
**
** Function gatt_free_pending_enc_queue
**
** Description Free all buffers in pending encyption queue
**
** Returns None
**
*******************************************************************************/
void gatt_free_pending_enc_queue(tGATT_TCB *p_tcb)
{
GATT_TRACE_DEBUG("gatt_free_pending_enc_queue");
/* release all queued indications */
while (!GKI_queue_is_empty(&p_tcb->pending_enc_clcb)) {
GKI_freebuf (GKI_dequeue (&p_tcb->pending_enc_clcb));
}
}
/*******************************************************************************
**
** Function gatt_free_pending_prepare_write_queue
**
** Description Free all buffers in pending prepare write packets queue
**
** Returns None
**
*******************************************************************************/
void gatt_free_pending_prepare_write_queue(tGATT_TCB *p_tcb)
{
GATT_TRACE_DEBUG("gatt_free_pending_prepare_write_queue");
/* release all queued prepare write packets */
while (!GKI_queue_is_empty(&(p_tcb->prepare_write_record.queue))) {
GKI_freebuf (GKI_dequeue (&(p_tcb->prepare_write_record.queue)));
}
p_tcb->prepare_write_record.total_num = 0;
p_tcb->prepare_write_record.error_code_app = GATT_SUCCESS;
}
/*******************************************************************************
**
** Function gatt_delete_dev_from_srv_chg_clt_list
**
** Description Delete a device from the service changed client lit
**
** Returns None
**
*******************************************************************************/
void gatt_delete_dev_from_srv_chg_clt_list(BD_ADDR bd_addr)
{
tGATTS_SRV_CHG *p_buf;
tGATTS_SRV_CHG_REQ req;
GATT_TRACE_DEBUG ("gatt_delete_dev_from_srv_chg_clt_list");
if ((p_buf = gatt_is_bda_in_the_srv_chg_clt_list(bd_addr)) != NULL) {
if (gatt_cb.cb_info.p_srv_chg_callback) {
/* delete from NV */
memcpy(req.srv_chg.bda, bd_addr, BD_ADDR_LEN);
(*gatt_cb.cb_info.p_srv_chg_callback)(GATTS_SRV_CHG_CMD_REMOVE_CLIENT, &req, NULL);
}
GKI_freebuf (GKI_remove_from_queue (&gatt_cb.srv_chg_clt_q, p_buf));
}
}
/*******************************************************************************
**
** Function gatt_set_srv_chg
**
** Description Set the service changed flag to TRUE
**
** Returns None
**
*******************************************************************************/
void gatt_set_srv_chg(void)
{
tGATTS_SRV_CHG *p_buf = (tGATTS_SRV_CHG *)GKI_getfirst(&gatt_cb.srv_chg_clt_q);
tGATTS_SRV_CHG_REQ req;
GATT_TRACE_DEBUG ("gatt_set_srv_chg");
while (p_buf) {
GATT_TRACE_DEBUG ("found a srv_chg clt");
if (!p_buf->srv_changed) {
GATT_TRACE_DEBUG ("set srv_changed to TRUE");
p_buf->srv_changed = TRUE;
memcpy(&req.srv_chg, p_buf, sizeof(tGATTS_SRV_CHG));
if (gatt_cb.cb_info.p_srv_chg_callback) {
(*gatt_cb.cb_info.p_srv_chg_callback)(GATTS_SRV_CHG_CMD_UPDATE_CLIENT, &req, NULL);
}
}
p_buf = (tGATTS_SRV_CHG *)GKI_getnext(p_buf);
}
}
/*******************************************************************************
**
** Function gatt_sr_is_new_srv_chg
**
** Description Find the app id in on the new service changed list
**
** Returns Pointer to the found new service changed item othwerwise NULL
**
*******************************************************************************/
tGATTS_PENDING_NEW_SRV_START *gatt_sr_is_new_srv_chg(tBT_UUID *p_app_uuid128, tBT_UUID *p_svc_uuid, UINT16 svc_inst)
{
tGATTS_HNDL_RANGE *p;
tGATTS_PENDING_NEW_SRV_START *p_buf = (tGATTS_PENDING_NEW_SRV_START *)GKI_getfirst(&gatt_cb.pending_new_srv_start_q);
while (p_buf != NULL) {
p = p_buf->p_new_srv_start;
if ( gatt_uuid_compare (*p_app_uuid128, p->app_uuid128)
&& gatt_uuid_compare (*p_svc_uuid, p->svc_uuid)
&& (svc_inst == p->svc_inst) ) {
GATT_TRACE_DEBUG ("gatt_sr_is_new_srv_chg: Yes");
break;
}
p_buf = (tGATTS_PENDING_NEW_SRV_START *)GKI_getnext(p_buf);
}
return p_buf;
}
/*******************************************************************************
**
** Function gatt_add_pending_ind
**
** Description Add a pending indication
**
** Returns Pointer to the current pending indication buffer, NULL no buffer available
**
*******************************************************************************/
tGATT_VALUE *gatt_add_pending_ind(tGATT_TCB *p_tcb, tGATT_VALUE *p_ind)
{
tGATT_VALUE *p_buf;
GATT_TRACE_DEBUG ("gatt_add_pending_ind");
if ((p_buf = (tGATT_VALUE *)GKI_getbuf((UINT16)sizeof(tGATT_VALUE))) != NULL) {
GATT_TRACE_DEBUG ("enqueue a pending indication");
memcpy(p_buf, p_ind, sizeof(tGATT_VALUE));
GKI_enqueue (&p_tcb->pending_ind_q, p_buf);
}
return p_buf;
}
/*******************************************************************************
**
** Function gatt_add_pending_new_srv_start
**
** Description Add a pending new srv start to the new service start queue
**
** Returns Pointer to the new service start buffer, NULL no buffer available
**
*******************************************************************************/
tGATTS_PENDING_NEW_SRV_START *gatt_add_pending_new_srv_start(tGATTS_HNDL_RANGE *p_new_srv_start)
{
tGATTS_PENDING_NEW_SRV_START *p_buf;
GATT_TRACE_DEBUG ("gatt_add_pending_new_srv_start");
if ((p_buf = (tGATTS_PENDING_NEW_SRV_START *)GKI_getbuf((UINT16)sizeof(tGATTS_PENDING_NEW_SRV_START))) != NULL) {
GATT_TRACE_DEBUG ("enqueue a new pending new srv start");
p_buf->p_new_srv_start = p_new_srv_start;
GKI_enqueue (&gatt_cb.pending_new_srv_start_q, p_buf);
}
return p_buf;
}
/*******************************************************************************
**
** Function gatt_add_srv_chg_clt
**
** Description Add a service chnage client to the service change client queue
**
** Returns Pointer to the service change client buffer; Null no buffer available
**
*******************************************************************************/
tGATTS_SRV_CHG *gatt_add_srv_chg_clt(tGATTS_SRV_CHG *p_srv_chg)
{
tGATTS_SRV_CHG *p_buf;
GATT_TRACE_DEBUG ("gatt_add_srv_chg_clt");
if ((p_buf = (tGATTS_SRV_CHG *)GKI_getbuf((UINT16)sizeof(tGATTS_SRV_CHG))) != NULL) {
GATT_TRACE_DEBUG ("enqueue a srv chg client");
memcpy(p_buf, p_srv_chg, sizeof(tGATTS_SRV_CHG));
GKI_enqueue (&gatt_cb.srv_chg_clt_q, p_buf);
}
return p_buf;
}
/*******************************************************************************
**
** Function gatt_alloc_hdl_buffer
**
** Description Allocate a handle buufer
**
** Returns Pointer to the allocated buffer, NULL no buffer available
**
*******************************************************************************/
tGATT_HDL_LIST_ELEM *gatt_alloc_hdl_buffer(void)
{
UINT8 i;
tGATT_CB *p_cb = &gatt_cb;
tGATT_HDL_LIST_ELEM *p_elem = &p_cb->hdl_list[0];
for (i = 0; i < GATT_MAX_SR_PROFILES; i++, p_elem ++) {
if (!p_cb->hdl_list[i].in_use) {
memset(p_elem, 0, sizeof(tGATT_HDL_LIST_ELEM));
p_elem->in_use = TRUE;
return p_elem;
}
}
return NULL;
}
/*******************************************************************************
**
** Function gatt_find_hdl_buffer_by_handle
**
** Description Find handle range buffer by service handle.
**
** Returns Pointer to the buffer, NULL no buffer available
**
*******************************************************************************/
tGATT_HDL_LIST_ELEM *gatt_find_hdl_buffer_by_handle(UINT16 handle)
{
tGATT_HDL_LIST_INFO *p_list_info = &gatt_cb.hdl_list_info;
tGATT_HDL_LIST_ELEM *p_list = NULL;
p_list = p_list_info->p_first;
while (p_list != NULL) {
if (p_list->in_use && p_list->asgn_range.s_handle == handle) {
return (p_list);
}
p_list = p_list->p_next;
}
return NULL;
}
/*******************************************************************************
**
** Function gatt_find_hdl_buffer_by_attr_handle
**
** Description Find handle range buffer by attribute handle.
**
** Returns Pointer to the buffer, NULL no buffer available
**
*******************************************************************************/
tGATT_HDL_LIST_ELEM *gatt_find_hdl_buffer_by_attr_handle(UINT16 attr_handle)
{
tGATT_HDL_LIST_INFO *p_list_info = &gatt_cb.hdl_list_info;
tGATT_HDL_LIST_ELEM *p_list = NULL;
p_list = p_list_info->p_first;
while (p_list != NULL) {
if (p_list->in_use && (p_list->asgn_range.s_handle <= attr_handle)
&& (p_list->asgn_range.e_handle >= attr_handle)) {
return (p_list);
}
p_list = p_list->p_next;
}
return NULL;
}
/*******************************************************************************
**
** Function gatt_find_hdl_buffer_by_app_id
**
** Description Find handle range buffer by app ID, service and service instance ID.
**
** Returns Pointer to the buffer, NULL no buffer available
**
*******************************************************************************/
tGATT_HDL_LIST_ELEM *gatt_find_hdl_buffer_by_app_id (tBT_UUID *p_app_uuid128,
tBT_UUID *p_svc_uuid,
UINT16 svc_inst)
{
tGATT_HDL_LIST_INFO *p_list_info = &gatt_cb.hdl_list_info;
tGATT_HDL_LIST_ELEM *p_list = NULL;
p_list = p_list_info->p_first;
while (p_list != NULL) {
if ( gatt_uuid_compare (*p_app_uuid128, p_list->asgn_range.app_uuid128)
&& gatt_uuid_compare (*p_svc_uuid, p_list->asgn_range.svc_uuid)
&& (svc_inst == p_list->asgn_range.svc_inst) ) {
GATT_TRACE_DEBUG ("Already allocated handles for this service before!!");
return (p_list);
}
p_list = p_list->p_next;
}
return NULL;
}
/*******************************************************************************
**
** Function gatt_free_hdl_buffer
**
** Description free a handle buffer
**
** Returns None
**
*******************************************************************************/
void gatt_free_hdl_buffer(tGATT_HDL_LIST_ELEM *p)
{
if (p) {
while (!GKI_queue_is_empty(&p->svc_db.svc_buffer)) {
GKI_freebuf (GKI_dequeue (&p->svc_db.svc_buffer));
}
memset(p, 0, sizeof(tGATT_HDL_LIST_ELEM));
}
}
/*******************************************************************************
**
** Function gatt_free_srvc_db_buffer_app_id
**
** Description free the service attribute database buffers by the owner of the
** service app ID.
**
** Returns None
**
*******************************************************************************/
void gatt_free_srvc_db_buffer_app_id(tBT_UUID *p_app_id)
{
tGATT_HDL_LIST_ELEM *p_elem = &gatt_cb.hdl_list[0];
UINT8 i;
for (i = 0; i < GATT_MAX_SR_PROFILES; i ++, p_elem ++) {
if (memcmp(p_app_id, &p_elem->asgn_range.app_uuid128, sizeof(tBT_UUID)) == 0) {
while (!GKI_queue_is_empty(&p_elem->svc_db.svc_buffer)) {
GKI_freebuf (GKI_dequeue (&p_elem->svc_db.svc_buffer));
}
p_elem->svc_db.mem_free = 0;
p_elem->svc_db.p_attr_list = p_elem->svc_db.p_free_mem = NULL;
}
}
}
/*******************************************************************************
**
** Function gatt_is_last_attribute
**
** Description Check this is the last attribute of the specified value or not
**
** Returns TRUE - yes this is the last attribute
**
*******************************************************************************/
BOOLEAN gatt_is_last_attribute(tGATT_SRV_LIST_INFO *p_list, tGATT_SRV_LIST_ELEM *p_start, tBT_UUID value)
{
tGATT_SRV_LIST_ELEM *p_srv = p_start->p_next;
BOOLEAN is_last_attribute = TRUE;
tGATT_SR_REG *p_rcb = NULL;
tBT_UUID *p_svc_uuid;
p_list->p_last_primary = NULL;
while (p_srv) {
p_rcb = GATT_GET_SR_REG_PTR(p_srv->i_sreg);
p_svc_uuid = gatts_get_service_uuid (p_rcb->p_db);
if (gatt_uuid_compare(value, *p_svc_uuid)) {
is_last_attribute = FALSE;
break;
}
p_srv = p_srv->p_next;
}
return is_last_attribute;
}
/*******************************************************************************
**
** Function gatt_update_last_pri_srv_info
**
** Description Update the the last primary info for the service list info
**
** Returns None
**
*******************************************************************************/
void gatt_update_last_pri_srv_info(tGATT_SRV_LIST_INFO *p_list)
{
tGATT_SRV_LIST_ELEM *p_srv = p_list->p_first;
p_list->p_last_primary = NULL;
while (p_srv) {
if (p_srv->is_primary) {
p_list->p_last_primary = p_srv;
}
p_srv = p_srv->p_next;
}
}
/*******************************************************************************
**
** Function gatts_update_srv_list_elem
**
** Description update an element in the service list.
**
** Returns None.
**
*******************************************************************************/
void gatts_update_srv_list_elem(UINT8 i_sreg, UINT16 handle, BOOLEAN is_primary)
{
UNUSED(handle);
gatt_cb.srv_list[i_sreg].in_use = TRUE;
gatt_cb.srv_list[i_sreg].i_sreg = i_sreg;
gatt_cb.srv_list[i_sreg].s_hdl = gatt_cb.sr_reg[i_sreg].s_hdl;
gatt_cb.srv_list[i_sreg].is_primary = is_primary;
return;
}
/*******************************************************************************
**
** Function gatt_add_a_srv_to_list
**
** Description add an service to the list in ascending
** order of the start handle
**
** Returns BOOLEAN TRUE-if add is successful
**
*******************************************************************************/
BOOLEAN gatt_add_a_srv_to_list(tGATT_SRV_LIST_INFO *p_list, tGATT_SRV_LIST_ELEM *p_new)
{
tGATT_SRV_LIST_ELEM *p_old;
if (!p_new) {
GATT_TRACE_DEBUG("p_new==NULL");
return FALSE;
}
if (!p_list->p_first) {
/* this is an empty list */
p_list->p_first =
p_list->p_last = p_new;
p_new->p_next =
p_new->p_prev = NULL;
} else {
p_old = p_list->p_first;
while (1) {
if (p_old == NULL) {
p_list->p_last->p_next = p_new;
p_new->p_prev = p_list->p_last;
p_new->p_next = NULL;
p_list->p_last = p_new;
break;
} else {
if (p_new->s_hdl < p_old->s_hdl) {
/* if not the first in list */
if (p_old->p_prev != NULL) {
p_old->p_prev->p_next = p_new;
} else {
p_list->p_first = p_new;
}
p_new->p_prev = p_old->p_prev;
p_new->p_next = p_old;
p_old->p_prev = p_new;
break;
}
}
p_old = p_old->p_next;
}
}
p_list->count++;
gatt_update_last_pri_srv_info(p_list);
return TRUE;
}
/*******************************************************************************
**
** Function gatt_remove_a_srv_from_list
**
** Description Remove a service from the list
**
** Returns BOOLEAN TRUE-if remove is successful
**
*******************************************************************************/
BOOLEAN gatt_remove_a_srv_from_list(tGATT_SRV_LIST_INFO *p_list, tGATT_SRV_LIST_ELEM *p_remove)
{
if (!p_remove || !p_list->p_first) {
GATT_TRACE_DEBUG("p_remove==NULL || p_list->p_first==NULL");
return FALSE;
}
if (p_remove->p_prev == NULL) {
p_list->p_first = p_remove->p_next;
if (p_remove->p_next) {
p_remove->p_next->p_prev = NULL;
}
} else if (p_remove->p_next == NULL) {
p_list->p_last = p_remove->p_prev;
p_remove->p_prev->p_next = NULL;
} else {
p_remove->p_next->p_prev = p_remove->p_prev;
p_remove->p_prev->p_next = p_remove->p_next;
}
p_list->count--;
gatt_update_last_pri_srv_info(p_list);
return TRUE;
}
/*******************************************************************************
**
** Function gatt_add_an_item_to_list
**
** Description add an service handle range to the list in decending
** order of the start handle
**
** Returns BOOLEAN TRUE-if add is successful
**
*******************************************************************************/
BOOLEAN gatt_add_an_item_to_list(tGATT_HDL_LIST_INFO *p_list, tGATT_HDL_LIST_ELEM *p_new)
{
tGATT_HDL_LIST_ELEM *p_old;
if (!p_new) {
GATT_TRACE_DEBUG("p_new==NULL");
return FALSE;
}
if (!p_list->p_first) {
/* this is an empty list */
p_list->p_first =
p_list->p_last = p_new;
p_new->p_next =
p_new->p_prev = NULL;
} else {
p_old = p_list->p_first;
while (1) {
if (p_old == NULL) {
p_list->p_last->p_next = p_new;
p_new->p_prev = p_list->p_last;
p_new->p_next = NULL;
p_list->p_last = p_new;
break;
} else {
if (p_new->asgn_range.s_handle > p_old->asgn_range.s_handle) {
if (p_old == p_list->p_first) {
p_list->p_first = p_new;
}
p_new->p_prev = p_old->p_prev;
p_new->p_next = p_old;
p_old->p_prev = p_new;
break;
}
}
p_old = p_old->p_next;
}
}
p_list->count++;
return TRUE;
}
/*******************************************************************************
**
** Function gatt_remove_an_item_from_list
**
** Description Remove an service handle range from the list
**
** Returns BOOLEAN TRUE-if remove is successful
**
*******************************************************************************/
BOOLEAN gatt_remove_an_item_from_list(tGATT_HDL_LIST_INFO *p_list, tGATT_HDL_LIST_ELEM *p_remove)
{
if (!p_remove || !p_list->p_first) {
GATT_TRACE_DEBUG("p_remove==NULL || p_list->p_first==NULL");
return FALSE;
}
if (p_remove->p_prev == NULL) {
p_list->p_first = p_remove->p_next;
if (p_remove->p_next) {
p_remove->p_next->p_prev = NULL;
}
} else if (p_remove->p_next == NULL) {
p_list->p_last = p_remove->p_prev;
p_remove->p_prev->p_next = NULL;
} else {
p_remove->p_next->p_prev = p_remove->p_prev;
p_remove->p_prev->p_next = p_remove->p_next;
}
p_list->count--;
return TRUE;
}
/*******************************************************************************
**
** Function gatt_find_the_connected_bda
**
** Description This function find the connected bda
**
** Returns TRUE if found
**
*******************************************************************************/
BOOLEAN gatt_find_the_connected_bda(UINT8 start_idx, BD_ADDR bda, UINT8 *p_found_idx,
tBT_TRANSPORT *p_transport)
{
UINT8 i;
BOOLEAN found = FALSE;
GATT_TRACE_DEBUG("gatt_find_the_connected_bda start_idx=%d", start_idx);
for (i = start_idx ; i < GATT_MAX_PHY_CHANNEL; i ++) {
if (gatt_cb.tcb[i].in_use && gatt_cb.tcb[i].ch_state == GATT_CH_OPEN) {
memcpy( bda, gatt_cb.tcb[i].peer_bda, BD_ADDR_LEN);
*p_found_idx = i;
*p_transport = gatt_cb.tcb[i].transport;
found = TRUE;
GATT_TRACE_DEBUG("gatt_find_the_connected_bda bda :%02x-%02x-%02x-%02x-%02x-%02x",
bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
break;
}
}
GATT_TRACE_DEBUG("gatt_find_the_connected_bda found=%d found_idx=%d", found, i);
return found;
}
/*******************************************************************************
**
** Function gatt_is_srv_chg_ind_pending
**
** Description Check whether a service chnaged is in the indication pending queue
** or waiting for an Ack already
**
** Returns BOOLEAN
**
*******************************************************************************/
BOOLEAN gatt_is_srv_chg_ind_pending (tGATT_TCB *p_tcb)
{
tGATT_VALUE *p_buf = (tGATT_VALUE *)GKI_getfirst(&p_tcb->pending_ind_q);
BOOLEAN srv_chg_ind_pending = FALSE;
GATT_TRACE_DEBUG("gatt_is_srv_chg_ind_pending is_queue_empty=%d", GKI_queue_is_empty(&p_tcb->pending_ind_q) );
if (p_tcb->indicate_handle == gatt_cb.handle_of_h_r) {
srv_chg_ind_pending = TRUE;
} else {
while (p_buf) {
if (p_buf->handle == gatt_cb.handle_of_h_r) {
srv_chg_ind_pending = TRUE;
break;
}
p_buf = (tGATT_VALUE *)GKI_getnext(p_buf);
}
}
GATT_TRACE_DEBUG("srv_chg_ind_pending = %d", srv_chg_ind_pending);
return srv_chg_ind_pending;
}
/*******************************************************************************
**
** Function gatt_is_bda_in_the_srv_chg_clt_list
**
** Description This function check the specified bda is in the srv chg clinet list or not
**
** Returns pointer to the found elemenet otherwise NULL
**
*******************************************************************************/
tGATTS_SRV_CHG *gatt_is_bda_in_the_srv_chg_clt_list (BD_ADDR bda)
{
tGATTS_SRV_CHG *p_buf = (tGATTS_SRV_CHG *)GKI_getfirst(&gatt_cb.srv_chg_clt_q);
GATT_TRACE_DEBUG("gatt_is_bda_in_the_srv_chg_clt_list :%02x-%02x-%02x-%02x-%02x-%02x",
bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
while (p_buf != NULL) {
if (!memcmp( bda, p_buf->bda, BD_ADDR_LEN)) {
GATT_TRACE_DEBUG("bda is in the srv chg clt list");
break;
}
p_buf = (tGATTS_SRV_CHG *)GKI_getnext(p_buf);
}
return p_buf;
}
/*******************************************************************************
**
** Function gatt_is_bda_connected
**
** Description
**
** Returns GATT_INDEX_INVALID if not found. Otherwise index to the tcb.
**
*******************************************************************************/
BOOLEAN gatt_is_bda_connected(BD_ADDR bda)
{
UINT8 i = 0;
BOOLEAN connected = FALSE;
for ( i = 0; i < GATT_MAX_PHY_CHANNEL; i ++) {
if (gatt_cb.tcb[i].in_use &&
!memcmp(gatt_cb.tcb[i].peer_bda, bda, BD_ADDR_LEN)) {
connected = TRUE;
break;
}
}
return connected;
}
/*******************************************************************************
**
** Function gatt_find_i_tcb_by_addr
**
** Description The function searches for an empty tcb entry, and return the index.
**
** Returns GATT_INDEX_INVALID if not found. Otherwise index to the tcb.
**
*******************************************************************************/
UINT8 gatt_find_i_tcb_by_addr(BD_ADDR bda, tBT_TRANSPORT transport)
{
UINT8 i = 0;
for ( ; i < GATT_MAX_PHY_CHANNEL; i ++) {
if (!memcmp(gatt_cb.tcb[i].peer_bda, bda, BD_ADDR_LEN) &&
gatt_cb.tcb[i].transport == transport) {
return i;
}
}
return GATT_INDEX_INVALID;
}
/*******************************************************************************
**
** Function gatt_get_tcb_by_idx
**
** Description The function get TCB using the TCB index
**
** Returns NULL if not found. Otherwise index to the tcb.
**
*******************************************************************************/
tGATT_TCB *gatt_get_tcb_by_idx(UINT8 tcb_idx)
{
tGATT_TCB *p_tcb = NULL;
if ( (tcb_idx < GATT_MAX_PHY_CHANNEL) && gatt_cb.tcb[tcb_idx].in_use) {
p_tcb = &gatt_cb.tcb[tcb_idx];
}
return p_tcb;
}
/*******************************************************************************
**
** Function gatt_find_tcb_by_addr
**
** Description The function searches for an empty tcb entry, and return pointer.
**
** Returns NULL if not found. Otherwise index to the tcb.
**
*******************************************************************************/
tGATT_TCB *gatt_find_tcb_by_addr(BD_ADDR bda, tBT_TRANSPORT transport)
{
tGATT_TCB *p_tcb = NULL;
UINT8 i = 0;
if ((i = gatt_find_i_tcb_by_addr(bda, transport)) != GATT_INDEX_INVALID) {
p_tcb = &gatt_cb.tcb[i];
}
return p_tcb;
}
/*******************************************************************************
**
** Function gatt_find_i_tcb_free
**
** Description The function searches for an empty tcb entry, and return the index.
**
** Returns GATT_INDEX_INVALID if not found. Otherwise index to the tcb.
**
*******************************************************************************/
UINT8 gatt_find_i_tcb_free(void)
{
UINT8 i = 0, j = GATT_INDEX_INVALID;
for (i = 0; i < GATT_MAX_PHY_CHANNEL; i ++) {
if (!gatt_cb.tcb[i].in_use) {
j = i;
break;
}
}
return j;
}
/*******************************************************************************
**
** Function gatt_allocate_tcb_by_bdaddr
**
** Description The function locate or allocate new tcb entry for matching bda.
**
** Returns GATT_INDEX_INVALID if not found. Otherwise index to the tcb.
**
*******************************************************************************/
tGATT_TCB *gatt_allocate_tcb_by_bdaddr(BD_ADDR bda, tBT_TRANSPORT transport)
{
UINT8 i = 0;
BOOLEAN allocated = FALSE;
tGATT_TCB *p_tcb = NULL;
/* search for existing tcb with matching bda */
i = gatt_find_i_tcb_by_addr(bda, transport);
/* find free tcb */
if (i == GATT_INDEX_INVALID) {
i = gatt_find_i_tcb_free();
allocated = TRUE;
}
if (i != GATT_INDEX_INVALID) {
p_tcb = &gatt_cb.tcb[i];
if (allocated) {
memset(p_tcb, 0, sizeof(tGATT_TCB));
GKI_init_q (&p_tcb->pending_enc_clcb);
GKI_init_q (&p_tcb->pending_ind_q);
p_tcb->in_use = TRUE;
p_tcb->tcb_idx = i;
p_tcb->transport = transport;
}
memcpy(p_tcb->peer_bda, bda, BD_ADDR_LEN);
}
return p_tcb;
}
/*******************************************************************************
**
** Function gatt_convert_uuid16_to_uuid128
**
** Description Convert a 16 bits UUID to be an standard 128 bits one.
**
** Returns TRUE if two uuid match; FALSE otherwise.
**
*******************************************************************************/
void gatt_convert_uuid16_to_uuid128(UINT8 uuid_128[LEN_UUID_128], UINT16 uuid_16)
{
UINT8 *p = &uuid_128[LEN_UUID_128 - 4];
memcpy (uuid_128, base_uuid, LEN_UUID_128);
UINT16_TO_STREAM(p, uuid_16);
}
/*******************************************************************************
**
** Function gatt_convert_uuid32_to_uuid128
**
** Description Convert a 32 bits UUID to be an standard 128 bits one.
**
** Returns TRUE if two uuid match; FALSE otherwise.
**
*******************************************************************************/
void gatt_convert_uuid32_to_uuid128(UINT8 uuid_128[LEN_UUID_128], UINT32 uuid_32)
{
UINT8 *p = &uuid_128[LEN_UUID_128 - 4];
memcpy (uuid_128, base_uuid, LEN_UUID_128);
UINT32_TO_STREAM(p, uuid_32);
}
/*******************************************************************************
**
** Function gatt_uuid_compare
**
** Description Compare two UUID to see if they are the same.
**
** Returns TRUE if two uuid match; FALSE otherwise.
**
*******************************************************************************/
BOOLEAN gatt_uuid_compare (tBT_UUID src, tBT_UUID tar)
{
UINT8 su[LEN_UUID_128], tu[LEN_UUID_128];
UINT8 *ps, *pt;
/* any of the UUID is unspecified */
if (src.len == 0 || tar.len == 0) {
return TRUE;
}
/* If both are 16-bit, we can do a simple compare */
if (src.len == LEN_UUID_16 && tar.len == LEN_UUID_16) {
return src.uu.uuid16 == tar.uu.uuid16;
}
/* If both are 32-bit, we can do a simple compare */
if (src.len == LEN_UUID_32 && tar.len == LEN_UUID_32) {
return src.uu.uuid32 == tar.uu.uuid32;
}
/* One or both of the UUIDs is 128-bit */
if (src.len == LEN_UUID_16) {
/* convert a 16 bits UUID to 128 bits value */
gatt_convert_uuid16_to_uuid128(su, src.uu.uuid16);
ps = su;
} else if (src.len == LEN_UUID_32) {
gatt_convert_uuid32_to_uuid128(su, src.uu.uuid32);
ps = su;
} else {
ps = src.uu.uuid128;
}
if (tar.len == LEN_UUID_16) {
/* convert a 16 bits UUID to 128 bits value */
gatt_convert_uuid16_to_uuid128(tu, tar.uu.uuid16);
pt = tu;
} else if (tar.len == LEN_UUID_32) {
/* convert a 32 bits UUID to 128 bits value */
gatt_convert_uuid32_to_uuid128(tu, tar.uu.uuid32);
pt = tu;
} else {
pt = tar.uu.uuid128;
}
return (memcmp(ps, pt, LEN_UUID_128) == 0);
}
/*******************************************************************************
**
** Function gatt_build_uuid_to_stream
**
** Description Add UUID into stream.
**
** Returns UUID length.
**
*******************************************************************************/
UINT8 gatt_build_uuid_to_stream(UINT8 **p_dst, tBT_UUID uuid)
{
UINT8 *p = *p_dst;
UINT8 len = 0;
if (uuid.len == LEN_UUID_16) {
UINT16_TO_STREAM (p, uuid.uu.uuid16);
len = LEN_UUID_16;
} else if (uuid.len == LEN_UUID_32) { /* always convert 32 bits into 128 bits as alwats */
gatt_convert_uuid32_to_uuid128(p, uuid.uu.uuid32);
p += LEN_UUID_128;
len = LEN_UUID_128;
} else if (uuid.len == LEN_UUID_128) {
ARRAY_TO_STREAM (p, uuid.uu.uuid128, LEN_UUID_128);
len = LEN_UUID_128;
}
*p_dst = p;
return len;
}
/*******************************************************************************
**
** Function gatt_parse_uuid_from_cmd
**
** Description Convert a 128 bits UUID into a 16 bits UUID.
**
** Returns TRUE if command sent, otherwise FALSE.
**
*******************************************************************************/
BOOLEAN gatt_parse_uuid_from_cmd(tBT_UUID *p_uuid_rec, UINT16 uuid_size, UINT8 **p_data)
{
BOOLEAN is_base_uuid, ret = TRUE;
UINT8 xx;
UINT8 *p_uuid = *p_data;
memset(p_uuid_rec, 0, sizeof(tBT_UUID));
switch (uuid_size) {
case LEN_UUID_16:
p_uuid_rec->len = uuid_size;
STREAM_TO_UINT16 (p_uuid_rec->uu.uuid16, p_uuid);
*p_data += LEN_UUID_16;
break;
case LEN_UUID_128:
/* See if we can compress his UUID down to 16 or 32bit UUIDs */
is_base_uuid = TRUE;
for (xx = 0; xx < LEN_UUID_128 - 4; xx++) {
if (p_uuid[xx] != base_uuid[xx]) {
is_base_uuid = FALSE;
break;
}
}
if (is_base_uuid) {
if ((p_uuid[LEN_UUID_128 - 1] == 0) && (p_uuid[LEN_UUID_128 - 2] == 0)) {
p_uuid += (LEN_UUID_128 - 4);
p_uuid_rec->len = LEN_UUID_16;
STREAM_TO_UINT16(p_uuid_rec->uu.uuid16, p_uuid);
} else {
p_uuid += (LEN_UUID_128 - LEN_UUID_32);
p_uuid_rec->len = LEN_UUID_32;
STREAM_TO_UINT32(p_uuid_rec->uu.uuid32, p_uuid);
}
}
if (!is_base_uuid) {
p_uuid_rec->len = LEN_UUID_128;
memcpy(p_uuid_rec->uu.uuid128, p_uuid, LEN_UUID_128);
}
*p_data += LEN_UUID_128;
break;
/* do not allow 32 bits UUID in ATT PDU now */
case LEN_UUID_32:
GATT_TRACE_ERROR("DO NOT ALLOW 32 BITS UUID IN ATT PDU");
case 0:
default:
if (uuid_size != 0) {
ret = FALSE;
}
GATT_TRACE_WARNING("gatt_parse_uuid_from_cmd invalid uuid size");
break;
}
return ( ret);
}
/*******************************************************************************
**
** Function gatt_start_rsp_timer
**
** Description Start a wait_for_response timer.
**
** Returns TRUE if command sent, otherwise FALSE.
**
*******************************************************************************/
void gatt_start_rsp_timer(UINT16 clcb_idx)
{
tGATT_CLCB *p_clcb = &gatt_cb.clcb[clcb_idx];
UINT32 timeout = GATT_WAIT_FOR_RSP_TOUT;
p_clcb->rsp_timer_ent.param = (TIMER_PARAM_TYPE)p_clcb;
if (p_clcb->operation == GATTC_OPTYPE_DISCOVERY &&
p_clcb->op_subtype == GATT_DISC_SRVC_ALL) {
timeout = GATT_WAIT_FOR_DISC_RSP_TOUT;
}
btu_start_timer (&p_clcb->rsp_timer_ent, BTU_TTYPE_ATT_WAIT_FOR_RSP,
timeout);
}
/*******************************************************************************
**
** Function gatt_start_conf_timer
**
** Description Start a wait_for_confirmation timer.
**
** Returns TRUE if command sent, otherwise FALSE.
**
*******************************************************************************/
void gatt_start_conf_timer(tGATT_TCB *p_tcb)
{
p_tcb->conf_timer_ent.param = (TIMER_PARAM_TYPE)p_tcb;
btu_start_timer (&p_tcb->conf_timer_ent, BTU_TTYPE_ATT_WAIT_FOR_RSP,
GATT_WAIT_FOR_RSP_TOUT);
}
/*******************************************************************************
**
** Function gatt_start_ind_ack_timer
**
** Description start the application ack timer
**
** Returns void
**
*******************************************************************************/
void gatt_start_ind_ack_timer(tGATT_TCB *p_tcb)
{
p_tcb->ind_ack_timer_ent.param = (TIMER_PARAM_TYPE)p_tcb;
/* start notification cache timer */
btu_start_timer (&p_tcb->ind_ack_timer_ent, BTU_TTYPE_ATT_WAIT_FOR_IND_ACK,
GATT_WAIT_FOR_RSP_TOUT);
}
/*******************************************************************************
**
** Function gatt_rsp_timeout
**
** Description Called when GATT wait for ATT command response timer expires
**
** Returns void
**
*******************************************************************************/
void gatt_rsp_timeout(TIMER_LIST_ENT *p_tle)
{
tGATT_CLCB *p_clcb = (tGATT_CLCB *)p_tle->param;
if (p_clcb == NULL || p_clcb->p_tcb == NULL) {
GATT_TRACE_WARNING("gatt_rsp_timeout clcb is already deleted");
return;
}
if (p_clcb->operation == GATTC_OPTYPE_DISCOVERY &&
p_clcb->op_subtype == GATT_DISC_SRVC_ALL &&
p_clcb->retry_count < GATT_REQ_RETRY_LIMIT) {
UINT8 rsp_code;
GATT_TRACE_WARNING("gatt_rsp_timeout retry discovery primary service");
if (p_clcb != gatt_cmd_dequeue(p_clcb->p_tcb, &rsp_code)) {
GATT_TRACE_ERROR("gatt_rsp_timeout command queue out of sync, disconnect");
} else {
p_clcb->retry_count++;
gatt_act_discovery(p_clcb);
return;
}
}
GATT_TRACE_WARNING("gatt_rsp_timeout disconnecting...");
gatt_disconnect (p_clcb->p_tcb);
}
/*******************************************************************************
**
** Function gatt_ind_ack_timeout
**
** Description Called when GATT wait for ATT handle confirmation timeout
**
** Returns void
**
*******************************************************************************/
void gatt_ind_ack_timeout(TIMER_LIST_ENT *p_tle)
{
tGATT_TCB *p_tcb = (tGATT_TCB *)p_tle->param;
GATT_TRACE_WARNING("gatt_ind_ack_timeout send ack now");
if (p_tcb != NULL) {
p_tcb->ind_count = 0;
}
attp_send_cl_msg(((tGATT_TCB *)p_tle->param), 0, GATT_HANDLE_VALUE_CONF, NULL);
}
/*******************************************************************************
**
** Function gatt_sr_find_i_rcb_by_handle
**
** Description The function searches for a service that owns a specific handle.
**
** Returns GATT_MAX_SR_PROFILES if not found. Otherwise index of th eservice.
**
*******************************************************************************/
UINT8 gatt_sr_find_i_rcb_by_handle(UINT16 handle)
{
UINT8 i_rcb = 0;
for ( ; i_rcb < GATT_MAX_SR_PROFILES; i_rcb++) {
if (gatt_cb.sr_reg[i_rcb].in_use &&
gatt_cb.sr_reg[i_rcb].s_hdl <= handle &&
gatt_cb.sr_reg[i_rcb].e_hdl >= handle ) {
break;
}
}
return i_rcb;
}
/*******************************************************************************
**
** Function gatt_sr_find_i_rcb_by_handle
**
** Description The function searches for a service that owns a specific handle.
**
** Returns 0 if not found. Otherwise index of th eservice.
**
*******************************************************************************/
UINT8 gatt_sr_find_i_rcb_by_app_id(tBT_UUID *p_app_uuid128, tBT_UUID *p_svc_uuid, UINT16 svc_inst)
{
UINT8 i_rcb = 0;
tGATT_SR_REG *p_sreg;
tBT_UUID *p_this_uuid;
for (i_rcb = 0, p_sreg = gatt_cb.sr_reg; i_rcb < GATT_MAX_SR_PROFILES; i_rcb++, p_sreg++) {
if ( p_sreg->in_use ) {
p_this_uuid = gatts_get_service_uuid (p_sreg->p_db);
if (p_this_uuid &&
gatt_uuid_compare (*p_app_uuid128, p_sreg->app_uuid ) &&
gatt_uuid_compare (*p_svc_uuid, *p_this_uuid) &&
(svc_inst == p_sreg->service_instance)) {
GATT_TRACE_ERROR ("Active Service Found ");
gatt_dbg_display_uuid(*p_svc_uuid);
break;
}
}
}
return i_rcb;
}
/*******************************************************************************
**
** Function gatt_sr_find_i_rcb_by_handle
**
** Description The function searches for a service that owns a specific handle.
**
** Returns 0 if not found. Otherwise index of th eservice.
**
*******************************************************************************/
UINT8 gatt_sr_alloc_rcb(tGATT_HDL_LIST_ELEM *p_list )
{
UINT8 ii = 0;
tGATT_SR_REG *p_sreg = NULL;
/*this is a new application servoce start */
for (ii = 0, p_sreg = gatt_cb.sr_reg; ii < GATT_MAX_SR_PROFILES; ii++, p_sreg++) {
if (!p_sreg->in_use) {
memset (p_sreg, 0, sizeof(tGATT_SR_REG));
p_sreg->in_use = TRUE;
memcpy (&p_sreg->app_uuid, &p_list->asgn_range.app_uuid128, sizeof(tBT_UUID));
p_sreg->service_instance = p_list->asgn_range.svc_inst;
p_sreg->type = p_list->asgn_range.is_primary ? GATT_UUID_PRI_SERVICE : GATT_UUID_SEC_SERVICE;
p_sreg->s_hdl = p_list->asgn_range.s_handle;
p_sreg->e_hdl = p_list->asgn_range.e_handle;
p_sreg->p_db = &p_list->svc_db;
GATT_TRACE_DEBUG ("total GKI buffer in db [%d]", GKI_queue_length(&p_sreg->p_db->svc_buffer));
break;
}
}
return ii;
}
/*******************************************************************************
**
** Function gatt_sr_get_sec_info
**
** Description Get the security flag and key size information for the peer
** device.
**
** Returns void
**
*******************************************************************************/
void gatt_sr_get_sec_info(BD_ADDR rem_bda, tBT_TRANSPORT transport, UINT8 *p_sec_flag, UINT8 *p_key_size)
{
UINT8 sec_flag = 0;
BTM_GetSecurityFlagsByTransport(rem_bda, &sec_flag, transport);
sec_flag &= (GATT_SEC_FLAG_LKEY_UNAUTHED | GATT_SEC_FLAG_LKEY_AUTHED | GATT_SEC_FLAG_ENCRYPTED);
*p_key_size = btm_ble_read_sec_key_size(rem_bda);
*p_sec_flag = sec_flag;
}
/*******************************************************************************
**
** Function gatt_sr_send_req_callback
**
** Description
**
**
** Returns void
**
*******************************************************************************/
void gatt_sr_send_req_callback(UINT16 conn_id,
UINT32 trans_id,
tGATTS_REQ_TYPE type, tGATTS_DATA *p_data)
{
tGATT_IF gatt_if = GATT_GET_GATT_IF(conn_id);
tGATT_REG *p_reg = gatt_get_regcb(gatt_if);
if (!p_reg ) {
GATT_TRACE_ERROR ("p_reg not found discard request");
return;
}
if ( p_reg->in_use &&
p_reg->app_cb.p_req_cb) {
(*p_reg->app_cb.p_req_cb)(conn_id, trans_id, type, p_data);
} else {
GATT_TRACE_WARNING("Call back not found for application conn_id=%d", conn_id);
}
}
/*******************************************************************************
**
** Function gatt_send_error_rsp
**
** Description This function sends an error response.
**
** Returns void
**
*******************************************************************************/
tGATT_STATUS gatt_send_error_rsp (tGATT_TCB *p_tcb, UINT8 err_code, UINT8 op_code,
UINT16 handle, BOOLEAN deq)
{
tGATT_ERROR error;
tGATT_STATUS status;
BT_HDR *p_buf;
error.cmd_code = op_code;
error.reason = err_code;
error.handle = handle;
if ((p_buf = attp_build_sr_msg(p_tcb, GATT_RSP_ERROR, (tGATT_SR_MSG *)&error)) != NULL) {
status = attp_send_sr_msg (p_tcb, p_buf);
} else {
status = GATT_INSUF_RESOURCE;
}
if (deq) {
gatt_dequeue_sr_cmd(p_tcb);
}
return status;
}
/*******************************************************************************
**
** Function gatt_add_sdp_record
**
** Description This function add a SDP record for a GATT primary service
**
** Returns 0 if error else sdp handle for the record.
**
*******************************************************************************/
UINT32 gatt_add_sdp_record (tBT_UUID *p_uuid, UINT16 start_hdl, UINT16 end_hdl)
{
tSDP_PROTOCOL_ELEM proto_elem_list[2];
UINT32 sdp_handle;
UINT16 list = UUID_SERVCLASS_PUBLIC_BROWSE_GROUP;
UINT8 buff[60];
UINT8 *p = buff;
GATT_TRACE_DEBUG("gatt_add_sdp_record s_hdl=0x%x s_hdl=0x%x", start_hdl, end_hdl);
if ((sdp_handle = SDP_CreateRecord()) == 0) {
return 0;
}
switch (p_uuid->len) {
case LEN_UUID_16:
SDP_AddServiceClassIdList(sdp_handle, 1, &p_uuid->uu.uuid16);
break;
case LEN_UUID_32:
UINT8_TO_BE_STREAM (p, (UUID_DESC_TYPE << 3) | SIZE_FOUR_BYTES);
UINT32_TO_BE_STREAM (p, p_uuid->uu.uuid32);
SDP_AddAttribute (sdp_handle, ATTR_ID_SERVICE_CLASS_ID_LIST, DATA_ELE_SEQ_DESC_TYPE,
(UINT32) (p - buff), buff);
break;
case LEN_UUID_128:
UINT8_TO_BE_STREAM (p, (UUID_DESC_TYPE << 3) | SIZE_SIXTEEN_BYTES);
ARRAY_TO_BE_STREAM_REVERSE (p, p_uuid->uu.uuid128, LEN_UUID_128);
SDP_AddAttribute (sdp_handle, ATTR_ID_SERVICE_CLASS_ID_LIST, DATA_ELE_SEQ_DESC_TYPE,
(UINT32) (p - buff), buff);
break;
default:
GATT_TRACE_ERROR("inavlid UUID len=%d", p_uuid->len);
SDP_DeleteRecord(sdp_handle);
return 0;
break;
}
/*** Fill out the protocol element sequence for SDP ***/
proto_elem_list[0].protocol_uuid = UUID_PROTOCOL_L2CAP;
proto_elem_list[0].num_params = 1;
proto_elem_list[0].params[0] = BT_PSM_ATT;
proto_elem_list[1].protocol_uuid = UUID_PROTOCOL_ATT;
proto_elem_list[1].num_params = 2;
proto_elem_list[1].params[0] = start_hdl;
proto_elem_list[1].params[1] = end_hdl;
SDP_AddProtocolList(sdp_handle, 2, proto_elem_list);
/* Make the service browseable */
SDP_AddUuidSequence (sdp_handle, ATTR_ID_BROWSE_GROUP_LIST, 1, &list);
return (sdp_handle);
}
#if GATT_CONFORMANCE_TESTING == TRUE
/*******************************************************************************
**
** Function gatt_set_err_rsp
**
** Description This function is called to set the test confirm value
**
** Returns void
**
*******************************************************************************/
void gatt_set_err_rsp(BOOLEAN enable, UINT8 req_op_code, UINT8 err_status)
{
GATT_TRACE_DEBUG("gatt_set_err_rsp enable=%d op_code=%d, err_status=%d", enable, req_op_code, err_status);
gatt_cb.enable_err_rsp = enable;
gatt_cb.req_op_code = req_op_code;
gatt_cb.err_status = err_status;
}
#endif
/*******************************************************************************
**
** Function gatt_get_regcb
**
** Description The function returns the registration control block.
**
** Returns pointer to the registration control block or NULL
**
*******************************************************************************/
tGATT_REG *gatt_get_regcb (tGATT_IF gatt_if)
{
UINT8 ii = (UINT8)gatt_if;
tGATT_REG *p_reg = NULL;
if (ii < 1 || ii > GATT_MAX_APPS) {
GATT_TRACE_WARNING("gatt_if out of range [ = %d]", ii);
return NULL;
}
// Index for cl_rcb is always 1 less than gatt_if.
p_reg = &gatt_cb.cl_rcb[ii - 1];
if (!p_reg->in_use) {
GATT_TRACE_WARNING("gatt_if found but not in use.\n");
return NULL;
}
return p_reg;
}
/*******************************************************************************
**
** Function gatt_is_clcb_allocated
**
** Description The function check clcb for conn_id is allocated or not
**
** Returns True already allocated
**
*******************************************************************************/
BOOLEAN gatt_is_clcb_allocated (UINT16 conn_id)
{
UINT8 i = 0;
BOOLEAN is_allocated = FALSE;
for (i = 0; i < GATT_CL_MAX_LCB; i++) {
if (gatt_cb.clcb[i].in_use && (gatt_cb.clcb[i].conn_id == conn_id)) {
is_allocated = TRUE;
break;
}
}
return is_allocated;
}
/*******************************************************************************
**
** Function gatt_clcb_alloc
**
** Description The function allocates a GATT connection link control block
**
** Returns NULL if not found. Otherwise pointer to the connection link block.
**
*******************************************************************************/
tGATT_CLCB *gatt_clcb_alloc (UINT16 conn_id)
{
UINT8 i = 0;
tGATT_CLCB *p_clcb = NULL;
tGATT_IF gatt_if = GATT_GET_GATT_IF(conn_id);
UINT8 tcb_idx = GATT_GET_TCB_IDX(conn_id);
tGATT_TCB *p_tcb = gatt_get_tcb_by_idx(tcb_idx);
tGATT_REG *p_reg = gatt_get_regcb(gatt_if);
for (i = 0; i < GATT_CL_MAX_LCB; i++) {
if (!gatt_cb.clcb[i].in_use) {
p_clcb = &gatt_cb.clcb[i];
p_clcb->in_use = TRUE;
p_clcb->conn_id = conn_id;
p_clcb->clcb_idx = i;
p_clcb->p_reg = p_reg;
p_clcb->p_tcb = p_tcb;
break;
}
}
return p_clcb;
}
/*******************************************************************************
**
** Function gatt_clcb_dealloc
**
** Description The function de allocates a GATT connection link control block
**
** Returns None
**
*******************************************************************************/
void gatt_clcb_dealloc (tGATT_CLCB *p_clcb)
{
if (p_clcb && p_clcb->in_use) {
memset(p_clcb, 0, sizeof(tGATT_CLCB));
}
}
/*******************************************************************************
**
** Function gatt_find_tcb_by_cid
**
** Description The function searches for an empty entry
** in registration info table for GATT client
**
** Returns NULL if not found. Otherwise pointer to the rcb.
**
*******************************************************************************/
tGATT_TCB *gatt_find_tcb_by_cid (UINT16 lcid)
{
UINT16 xx = 0;
tGATT_TCB *p_tcb = NULL;
for (xx = 0; xx < GATT_MAX_PHY_CHANNEL; xx++) {
if (gatt_cb.tcb[xx].in_use && gatt_cb.tcb[xx].att_lcid == lcid) {
p_tcb = &gatt_cb.tcb[xx];
break;
}
}
return p_tcb;
}
/*******************************************************************************
**
** Function gatt_num_apps_hold_link
**
** Description The function find the number of applcaitions is holding the link
**
** Returns total number of applications holding this acl link.
**
*******************************************************************************/
UINT8 gatt_num_apps_hold_link(tGATT_TCB *p_tcb)
{
UINT8 i, num = 0;
for (i = 0; i < GATT_MAX_APPS; i ++) {
if (p_tcb->app_hold_link[i]) {
num ++;
}
}
GATT_TRACE_DEBUG("gatt_num_apps_hold_link num=%d", num);
return num;
}
/*******************************************************************************
**
** Function gatt_num_clcb_by_bd_addr
**
** Description The function searches all LCB with macthing bd address
**
** Returns total number of clcb found.
**
*******************************************************************************/
UINT8 gatt_num_clcb_by_bd_addr(BD_ADDR bda)
{
UINT8 i, num = 0;
for (i = 0; i < GATT_CL_MAX_LCB; i ++) {
if (gatt_cb.clcb[i].in_use && memcmp(gatt_cb.clcb[i].p_tcb->peer_bda, bda, BD_ADDR_LEN) == 0) {
num ++;
}
}
return num;
}
/*******************************************************************************
**
** Function gatt_sr_update_cback_cnt
**
** Description The function searches all LCB with macthing bd address
**
** Returns total number of clcb found.
**
*******************************************************************************/
void gatt_sr_copy_prep_cnt_to_cback_cnt(tGATT_TCB *p_tcb )
{
UINT8 i;
if (p_tcb) {
for (i = 0; i < GATT_MAX_APPS; i ++) {
if (p_tcb->prep_cnt[i]) {
p_tcb->sr_cmd.cback_cnt[i] = 1;
}
}
}
}
/*******************************************************************************
**
** Function gatt_sr_is_cback_cnt_zero
**
** Description The function searches all LCB with macthing bd address
**
** Returns True if thetotal application callback count is zero
**
*******************************************************************************/
BOOLEAN gatt_sr_is_cback_cnt_zero(tGATT_TCB *p_tcb )
{
BOOLEAN status = TRUE;
UINT8 i;
if (p_tcb) {
for (i = 0; i < GATT_MAX_APPS; i ++) {
if (p_tcb->sr_cmd.cback_cnt[i]) {
status = FALSE;
break;
}
}
} else {
status = FALSE;
}
return status;
}
/*******************************************************************************
**
** Function gatt_sr_is_prep_cnt_zero
**
** Description Check the prepare write request count is zero or not
**
** Returns True no prepare write request
**
*******************************************************************************/
BOOLEAN gatt_sr_is_prep_cnt_zero(tGATT_TCB *p_tcb)
{
BOOLEAN status = TRUE;
UINT8 i;
if (p_tcb) {
for (i = 0; i < GATT_MAX_APPS; i ++) {
if (p_tcb->prep_cnt[i]) {
status = FALSE;
break;
}
}
} else {
status = FALSE;
}
return status;
}
/*******************************************************************************
**
** Function gatt_sr_reset_cback_cnt
**
** Description Reset the application callback count to zero
**
** Returns None
**
*******************************************************************************/
void gatt_sr_reset_cback_cnt(tGATT_TCB *p_tcb )
{
UINT8 i;
if (p_tcb) {
for (i = 0; i < GATT_MAX_APPS; i ++) {
p_tcb->sr_cmd.cback_cnt[i] = 0;
}
}
}
/*******************************************************************************
**
** Function gatt_sr_reset_prep_cnt
**
** Description Reset the prep write count to zero
**
** Returns None
**
*******************************************************************************/
void gatt_sr_reset_prep_cnt(tGATT_TCB *p_tcb )
{
UINT8 i;
if (p_tcb) {
for (i = 0; i < GATT_MAX_APPS; i ++) {
p_tcb->prep_cnt[i] = 0;
}
}
}
/*******************************************************************************
**
** Function gatt_sr_update_cback_cnt
**
** Description Update the teh applicaiton callback count
**
** Returns None
**
*******************************************************************************/
void gatt_sr_update_cback_cnt(tGATT_TCB *p_tcb, tGATT_IF gatt_if, BOOLEAN is_inc, BOOLEAN is_reset_first)
{
UINT8 idx = ((UINT8) gatt_if) - 1 ;
if (p_tcb) {
if (is_reset_first) {
gatt_sr_reset_cback_cnt(p_tcb);
}
if (is_inc) {
p_tcb->sr_cmd.cback_cnt[idx]++;
} else {
if ( p_tcb->sr_cmd.cback_cnt[idx]) {
p_tcb->sr_cmd.cback_cnt[idx]--;
}
}
}
}
/*******************************************************************************
**
** Function gatt_sr_update_prep_cnt
**
** Description Update the teh prepare write request count
**
** Returns None
**
*******************************************************************************/
void gatt_sr_update_prep_cnt(tGATT_TCB *p_tcb, tGATT_IF gatt_if, BOOLEAN is_inc, BOOLEAN is_reset_first)
{
UINT8 idx = ((UINT8) gatt_if) - 1 ;
GATT_TRACE_DEBUG("gatt_sr_update_prep_cnt tcb idx=%d gatt_if=%d is_inc=%d is_reset_first=%d",
p_tcb->tcb_idx, gatt_if, is_inc, is_reset_first);
if (p_tcb) {
if (is_reset_first) {
gatt_sr_reset_prep_cnt(p_tcb);
}
if (is_inc) {
p_tcb->prep_cnt[idx]++;
} else {
if (p_tcb->prep_cnt[idx]) {
p_tcb->prep_cnt[idx]--;
}
}
}
}
/*******************************************************************************
**
** Function gatt_cancel_open
**
** Description Cancel open request
**
** Returns Boolean
**
*******************************************************************************/
BOOLEAN gatt_cancel_open(tGATT_IF gatt_if, BD_ADDR bda)
{
tGATT_TCB *p_tcb = NULL;
BOOLEAN status = TRUE;
p_tcb = gatt_find_tcb_by_addr(bda, BT_TRANSPORT_LE);
if (p_tcb) {
if (gatt_get_ch_state(p_tcb) == GATT_CH_OPEN) {
GATT_TRACE_ERROR("GATT_CancelConnect - link connected Too late to cancel");
status = FALSE;
} else {
gatt_update_app_use_link_flag(gatt_if, p_tcb, FALSE, FALSE);
if (!gatt_num_apps_hold_link(p_tcb)) {
gatt_disconnect(p_tcb);
}
}
}
return status;
}
/*******************************************************************************
**
** Function gatt_find_app_hold_link
**
** Description find the applicaiton that is holding the specified link
**
** Returns Boolean
**
*******************************************************************************/
BOOLEAN gatt_find_app_hold_link(tGATT_TCB *p_tcb, UINT8 start_idx, UINT8 *p_found_idx, tGATT_IF *p_gatt_if)
{
UINT8 i;
BOOLEAN found = FALSE;
for (i = start_idx; i < GATT_MAX_APPS; i ++) {
if (p_tcb->app_hold_link[i]) {
*p_gatt_if = gatt_cb.clcb[i].p_reg->gatt_if;
*p_found_idx = i;
found = TRUE;
break;
}
}
return found;
}
/*******************************************************************************
**
** Function gatt_cmd_enq
**
** Description Enqueue this command.
**
** Returns None.
**
*******************************************************************************/
BOOLEAN gatt_cmd_enq(tGATT_TCB *p_tcb, UINT16 clcb_idx, BOOLEAN to_send, UINT8 op_code, BT_HDR *p_buf)
{
tGATT_CMD_Q *p_cmd = &p_tcb->cl_cmd_q[p_tcb->next_slot_inq];
p_cmd->to_send = to_send; /* waiting to be sent */
p_cmd->op_code = op_code;
p_cmd->p_cmd = p_buf;
p_cmd->clcb_idx = clcb_idx;
if (!to_send) {
p_tcb->pending_cl_req = p_tcb->next_slot_inq;
}
p_tcb->next_slot_inq ++;
p_tcb->next_slot_inq %= GATT_CL_MAX_LCB;
return TRUE;
}
/*******************************************************************************
**
** Function gatt_cmd_dequeue
**
** Description dequeue the command in the client CCB command queue.
**
** Returns total number of clcb found.
**
*******************************************************************************/
tGATT_CLCB *gatt_cmd_dequeue(tGATT_TCB *p_tcb, UINT8 *p_op_code)
{
tGATT_CMD_Q *p_cmd = &p_tcb->cl_cmd_q[p_tcb->pending_cl_req];
tGATT_CLCB *p_clcb = NULL;
if (p_tcb->pending_cl_req != p_tcb->next_slot_inq) {
p_clcb = &gatt_cb.clcb[p_cmd->clcb_idx];
*p_op_code = p_cmd->op_code;
p_tcb->pending_cl_req ++;
p_tcb->pending_cl_req %= GATT_CL_MAX_LCB;
}
return p_clcb;
}
/*******************************************************************************
**
** Function gatt_send_write_msg
**
** Description This real function send out the ATT message for write.
**
** Returns status code
**
*******************************************************************************/
UINT8 gatt_send_write_msg (tGATT_TCB *p_tcb, UINT16 clcb_idx, UINT8 op_code,
UINT16 handle, UINT16 len,
UINT16 offset, UINT8 *p_data)
{
tGATT_CL_MSG msg;
msg.attr_value.handle = handle;
msg.attr_value.len = len;
msg.attr_value.offset = offset;
memcpy (msg.attr_value.value, p_data, len);
/* write by handle */
return attp_send_cl_msg(p_tcb, clcb_idx, op_code, &msg);
}
/*******************************************************************************
**
** Function gatt_act_send_browse
**
** Description This function ends a browse command request, including read
** information request and read by type request.
**
** Returns status code
**
*******************************************************************************/
UINT8 gatt_act_send_browse(tGATT_TCB *p_tcb, UINT16 index, UINT8 op, UINT16 s_handle,
UINT16 e_handle, tBT_UUID uuid)
{
tGATT_CL_MSG msg;
msg.browse.s_handle = s_handle;
msg.browse.e_handle = e_handle;
memcpy(&msg.browse.uuid, &uuid, sizeof(tBT_UUID));
/* write by handle */
return attp_send_cl_msg(p_tcb, index, op, &msg);
}
/*******************************************************************************
**
** Function gatt_end_operation
**
** Description This function ends a discovery, send callback and finalize
** some control value.
**
** Returns 16 bits uuid.
**
*******************************************************************************/
void gatt_end_operation(tGATT_CLCB *p_clcb, tGATT_STATUS status, void *p_data)
{
tGATT_CL_COMPLETE cb_data;
tGATT_CMPL_CBACK *p_cmpl_cb = (p_clcb->p_reg) ? p_clcb->p_reg->app_cb.p_cmpl_cb : NULL;
UINT8 op = p_clcb->operation, disc_type = GATT_DISC_MAX;
tGATT_DISC_CMPL_CB *p_disc_cmpl_cb = (p_clcb->p_reg) ? p_clcb->p_reg->app_cb.p_disc_cmpl_cb : NULL;
UINT16 conn_id;
UINT8 operation;
GATT_TRACE_DEBUG ("gatt_end_operation status=%d op=%d subtype=%d",
status, p_clcb->operation, p_clcb->op_subtype);
memset(&cb_data.att_value, 0, sizeof(tGATT_VALUE));
if (p_cmpl_cb != NULL && p_clcb->operation != 0) {
if (p_clcb->operation == GATTC_OPTYPE_READ) {
cb_data.att_value.handle = p_clcb->s_handle;
cb_data.att_value.len = p_clcb->counter;
if (p_data && p_clcb->counter) {
memcpy (cb_data.att_value.value, p_data, cb_data.att_value.len);
}
}
if (p_clcb->operation == GATTC_OPTYPE_WRITE) {
memset(&cb_data.att_value, 0, sizeof(tGATT_VALUE));
cb_data.handle =
cb_data.att_value.handle = p_clcb->s_handle;
if (p_clcb->op_subtype == GATT_WRITE_PREPARE) {
if (p_data) {
cb_data.att_value = *((tGATT_VALUE *) p_data);
} else {
GATT_TRACE_DEBUG("Rcv Prepare write rsp but no data");
}
}
}
if (p_clcb->operation == GATTC_OPTYPE_CONFIG) {
cb_data.mtu = p_clcb->p_tcb->payload_size;
}
if (p_clcb->operation == GATTC_OPTYPE_DISCOVERY) {
disc_type = p_clcb->op_subtype;
}
}
if (p_clcb->p_attr_buf) {
GKI_freebuf(p_clcb->p_attr_buf);
}
operation = p_clcb->operation;
conn_id = p_clcb->conn_id;
btu_stop_timer(&p_clcb->rsp_timer_ent);
gatt_clcb_dealloc(p_clcb);
if (p_disc_cmpl_cb && (op == GATTC_OPTYPE_DISCOVERY)) {
(*p_disc_cmpl_cb)(conn_id, disc_type, status);
} else if (p_cmpl_cb && op) {
(*p_cmpl_cb)(conn_id, op, status, &cb_data);
} else
GATT_TRACE_WARNING ("gatt_end_operation not sent out op=%d p_disc_cmpl_cb:%p p_cmpl_cb:%p",
operation, p_disc_cmpl_cb, p_cmpl_cb);
}
/*******************************************************************************
**
** Function gatt_cleanup_upon_disc
**
** Description This function cleans up the control blocks when L2CAP channel
** disconnect.
**
** Returns 16 bits uuid.
**
*******************************************************************************/
void gatt_cleanup_upon_disc(BD_ADDR bda, UINT16 reason, tBT_TRANSPORT transport)
{
tGATT_TCB *p_tcb = NULL;
tGATT_CLCB *p_clcb;
UINT8 i;
UINT16 conn_id;
tGATT_REG *p_reg = NULL;
GATT_TRACE_DEBUG ("gatt_cleanup_upon_disc ");
if ((p_tcb = gatt_find_tcb_by_addr(bda, transport)) != NULL) {
GATT_TRACE_DEBUG ("found p_tcb ");
gatt_set_ch_state(p_tcb, GATT_CH_CLOSE);
for (i = 0; i < GATT_CL_MAX_LCB; i ++) {
p_clcb = &gatt_cb.clcb[i];
if (p_clcb->in_use && p_clcb->p_tcb == p_tcb) {
btu_stop_timer(&p_clcb->rsp_timer_ent);
GATT_TRACE_DEBUG ("found p_clcb conn_id=%d clcb_idx=%d", p_clcb->conn_id, p_clcb->clcb_idx);
if (p_clcb->operation != GATTC_OPTYPE_NONE) {
gatt_end_operation(p_clcb, GATT_ERROR, NULL);
}
gatt_clcb_dealloc(p_clcb);
}
}
btu_stop_timer (&p_tcb->ind_ack_timer_ent);
btu_stop_timer (&p_tcb->conf_timer_ent);
gatt_free_pending_ind(p_tcb);
gatt_free_pending_enc_queue(p_tcb);
gatt_free_pending_prepare_write_queue(p_tcb);
for (i = 0; i < GATT_MAX_APPS; i ++) {
p_reg = &gatt_cb.cl_rcb[i];
if (p_reg->in_use && p_reg->app_cb.p_conn_cb) {
conn_id = GATT_CREATE_CONN_ID(p_tcb->tcb_idx, p_reg->gatt_if);
GATT_TRACE_DEBUG ("found p_reg tcb_idx=%d gatt_if=%d conn_id=0x%x", p_tcb->tcb_idx, p_reg->gatt_if, conn_id);
(*p_reg->app_cb.p_conn_cb)(p_reg->gatt_if, bda, conn_id, FALSE, reason, transport);
}
}
memset(p_tcb, 0, sizeof(tGATT_TCB));
}
GATT_TRACE_DEBUG ("exit gatt_cleanup_upon_disc ");
}
/*******************************************************************************
**
** Function gatt_dbg_req_op_name
**
** Description Get op code description name, for debug information.
**
** Returns UINT8 *: name of the operation.
**
*******************************************************************************/
UINT8 *gatt_dbg_op_name(UINT8 op_code)
{
UINT8 pseduo_op_code_idx = op_code & (~GATT_WRITE_CMD_MASK);
if (op_code == GATT_CMD_WRITE ) {
pseduo_op_code_idx = 0x14; /* just an index to op_code_name */
}
if (op_code == GATT_SIGN_CMD_WRITE) {
pseduo_op_code_idx = 0x15; /* just an index to op_code_name */
}
if (pseduo_op_code_idx <= GATT_OP_CODE_MAX) {
return (UINT8 *) op_code_name[pseduo_op_code_idx];
} else {
return (UINT8 *)"Op Code Exceed Max";
}
}
/*******************************************************************************
**
** Function gatt_dbg_display_uuid
**
** Description Disaplay the UUID
**
** Returns None
**
*******************************************************************************/
void gatt_dbg_display_uuid(tBT_UUID bt_uuid)
{
char str_buf[50];
int x = 0;
if (bt_uuid.len == LEN_UUID_16) {
sprintf(str_buf, "0x%04x", bt_uuid.uu.uuid16);
} else if (bt_uuid.len == LEN_UUID_32) {
sprintf(str_buf, "0x%08x", (unsigned int)bt_uuid.uu.uuid32);
} else if (bt_uuid.len == LEN_UUID_128) {
x += sprintf(&str_buf[x], "0x%02x%02x%02x%02x%02x%02x%02x%02x",
bt_uuid.uu.uuid128[15], bt_uuid.uu.uuid128[14],
bt_uuid.uu.uuid128[13], bt_uuid.uu.uuid128[12],
bt_uuid.uu.uuid128[11], bt_uuid.uu.uuid128[10],
bt_uuid.uu.uuid128[9], bt_uuid.uu.uuid128[8]);
sprintf(&str_buf[x], "%02x%02x%02x%02x%02x%02x%02x%02x",
bt_uuid.uu.uuid128[7], bt_uuid.uu.uuid128[6],
bt_uuid.uu.uuid128[5], bt_uuid.uu.uuid128[4],
bt_uuid.uu.uuid128[3], bt_uuid.uu.uuid128[2],
bt_uuid.uu.uuid128[1], bt_uuid.uu.uuid128[0]);
} else {
BCM_STRNCPY_S(str_buf, sizeof(str_buf), "Unknown UUID 0", 15);
}
GATT_TRACE_DEBUG ("UUID=[%s]", str_buf);
}
/*******************************************************************************
**
** Function gatt_is_bg_dev_for_app
**
** Description find is this one of the background devices for the application
**
** Returns TRUE this is one of the background devices for the application
**
*******************************************************************************/
BOOLEAN gatt_is_bg_dev_for_app(tGATT_BG_CONN_DEV *p_dev, tGATT_IF gatt_if)
{
UINT8 i;
for (i = 0; i < GATT_MAX_APPS; i ++ ) {
if (p_dev->in_use && (p_dev->gatt_if[i] == gatt_if)) {
return TRUE;
}
}
return FALSE;
}
/*******************************************************************************
**
** Function gatt_find_bg_dev
**
** Description find background connection device from the list.
**
** Returns pointer to the device record
**
*******************************************************************************/
tGATT_BG_CONN_DEV *gatt_find_bg_dev(BD_ADDR remote_bda)
{
tGATT_BG_CONN_DEV *p_dev_list = &gatt_cb.bgconn_dev[0];
UINT8 i;
for (i = 0; i < GATT_MAX_BG_CONN_DEV; i ++, p_dev_list ++) {
if (p_dev_list->in_use && !memcmp(p_dev_list->remote_bda, remote_bda, BD_ADDR_LEN)) {
return p_dev_list;
}
}
return NULL;
}
/*******************************************************************************
**
** Function gatt_alloc_bg_dev
**
** Description allocate a background connection device record
**
** Returns pointer to the device record
**
*******************************************************************************/
tGATT_BG_CONN_DEV *gatt_alloc_bg_dev(BD_ADDR remote_bda)
{
tGATT_BG_CONN_DEV *p_dev_list = &gatt_cb.bgconn_dev[0];
UINT8 i;
for (i = 0; i < GATT_MAX_BG_CONN_DEV; i ++, p_dev_list ++) {
if (!p_dev_list->in_use) {
p_dev_list->in_use = TRUE;
memcpy(p_dev_list->remote_bda, remote_bda, BD_ADDR_LEN);
return p_dev_list;
}
}
return NULL;
}
/*******************************************************************************
**
** Function gatt_add_bg_dev_list
**
** Description add/remove device from the back ground connection device list
**
** Returns TRUE if device added to the list; FALSE failed
**
*******************************************************************************/
BOOLEAN gatt_add_bg_dev_list(tGATT_REG *p_reg, BD_ADDR bd_addr, BOOLEAN is_initator)
{
tGATT_IF gatt_if = p_reg->gatt_if;
tGATT_BG_CONN_DEV *p_dev = NULL;
UINT8 i;
BOOLEAN ret = FALSE;
if ((p_dev = gatt_find_bg_dev(bd_addr)) == NULL) {
p_dev = gatt_alloc_bg_dev(bd_addr);
}
if (p_dev) {
for (i = 0; i < GATT_MAX_APPS; i ++) {
if (is_initator) {
if (p_dev->gatt_if[i] == gatt_if) {
GATT_TRACE_ERROR("device already in iniator white list");
return TRUE;
} else if (p_dev->gatt_if[i] == 0) {
p_dev->gatt_if[i] = gatt_if;
if (i == 0) {
ret = BTM_BleUpdateBgConnDev(TRUE, bd_addr);
} else {
ret = TRUE;
}
break;
}
} else {
if (p_dev->listen_gif[i] == gatt_if) {
GATT_TRACE_ERROR("device already in adv white list");
return TRUE;
} else if (p_dev->listen_gif[i] == 0) {
if (p_reg->listening == GATT_LISTEN_TO_ALL) {
p_reg->listening = GATT_LISTEN_TO_NONE;
}
p_reg->listening ++;
p_dev->listen_gif[i] = gatt_if;
if (i == 0) {
ret = BTM_BleUpdateAdvWhitelist(TRUE, bd_addr);
} else {
ret = TRUE;
}
break;
}
}
}
} else {
GATT_TRACE_ERROR("no device record available");
}
return ret;
}
/*******************************************************************************
**
** Function gatt_remove_bg_dev_for_app
**
** Description Remove the application interface for the specified background device
**
** Returns Boolean
**
*******************************************************************************/
BOOLEAN gatt_remove_bg_dev_for_app(tGATT_IF gatt_if, BD_ADDR bd_addr)
{
tGATT_TCB *p_tcb = gatt_find_tcb_by_addr(bd_addr, BT_TRANSPORT_LE);
BOOLEAN status;
if (p_tcb) {
gatt_update_app_use_link_flag(gatt_if, p_tcb, FALSE, FALSE);
}
status = gatt_update_auto_connect_dev(gatt_if, FALSE, bd_addr, TRUE);
return status;
}
/*******************************************************************************
**
** Function gatt_get_num_apps_for_bg_dev
**
** Description Gte the number of applciations for the specified background device
**
** Returns UINT8 total number fo applications
**
*******************************************************************************/
UINT8 gatt_get_num_apps_for_bg_dev(BD_ADDR bd_addr)
{
tGATT_BG_CONN_DEV *p_dev = NULL;
UINT8 i;
UINT8 cnt = 0;
if ((p_dev = gatt_find_bg_dev(bd_addr)) != NULL) {
for (i = 0; i < GATT_MAX_APPS; i ++) {
if (p_dev->gatt_if[i]) {
cnt++;
}
}
}
return cnt;
}
/*******************************************************************************
**
** Function gatt_find_app_for_bg_dev
**
** Description find the application interface for the specified background device
**
** Returns Boolean
**
*******************************************************************************/
BOOLEAN gatt_find_app_for_bg_dev(BD_ADDR bd_addr, tGATT_IF *p_gatt_if)
{
tGATT_BG_CONN_DEV *p_dev = NULL;
UINT8 i;
BOOLEAN ret = FALSE;
if ((p_dev = gatt_find_bg_dev(bd_addr)) == NULL) {
return ret;
}
for (i = 0; i < GATT_MAX_APPS; i ++) {
if (p_dev->gatt_if[i] != 0 ) {
*p_gatt_if = p_dev->gatt_if[i];
ret = TRUE;
break;
}
}
return ret;
}
/*******************************************************************************
**
** Function gatt_remove_bg_dev_from_list
**
** Description add/remove device from the back ground connection device list or
** listening to advertising list.
**
** Returns pointer to the device record
**
*******************************************************************************/
BOOLEAN gatt_remove_bg_dev_from_list(tGATT_REG *p_reg, BD_ADDR bd_addr, BOOLEAN is_initiator)
{
tGATT_IF gatt_if = p_reg->gatt_if;
tGATT_BG_CONN_DEV *p_dev = NULL;
UINT8 i, j;
BOOLEAN ret = FALSE;
if ((p_dev = gatt_find_bg_dev(bd_addr)) == NULL) {
return ret;
}
for (i = 0; i < GATT_MAX_APPS && (p_dev->gatt_if[i] > 0 || p_dev->listen_gif[i]); i ++) {
if (is_initiator) {
if (p_dev->gatt_if[i] == gatt_if) {
p_dev->gatt_if[i] = 0;
/* move all element behind one forward */
for (j = i + 1; j < GATT_MAX_APPS; j ++) {
p_dev->gatt_if[j - 1] = p_dev->gatt_if[j];
}
if (p_dev->gatt_if[0] == 0) {
ret = BTM_BleUpdateBgConnDev(FALSE, p_dev->remote_bda);
} else {
ret = TRUE;
}
break;
}
} else {
if (p_dev->listen_gif[i] == gatt_if) {
p_dev->listen_gif[i] = 0;
p_reg->listening --;
/* move all element behind one forward */
for (j = i + 1; j < GATT_MAX_APPS; j ++) {
p_dev->listen_gif[j - 1] = p_dev->listen_gif[j];
}
if (p_dev->listen_gif[0] == 0) {
ret = BTM_BleUpdateAdvWhitelist(FALSE, p_dev->remote_bda);
} else {
ret = TRUE;
}
break;
}
}
}
if (i != GATT_MAX_APPS && p_dev->gatt_if[0] == 0 && p_dev->listen_gif[0] == 0) {
memset(p_dev, 0, sizeof(tGATT_BG_CONN_DEV));
}
return ret;
}
/*******************************************************************************
**
** Function gatt_deregister_bgdev_list
**
** Description deregister all related back ground connetion device.
**
** Returns pointer to the device record
**
*******************************************************************************/
void gatt_deregister_bgdev_list(tGATT_IF gatt_if)
{
tGATT_BG_CONN_DEV *p_dev_list = &gatt_cb.bgconn_dev[0];
UINT8 i , j, k;
tGATT_REG *p_reg = gatt_get_regcb(gatt_if);
/* update the BG conn device list */
for (i = 0 ; i < GATT_MAX_BG_CONN_DEV; i ++, p_dev_list ++ ) {
if (p_dev_list->in_use) {
for (j = 0; j < GATT_MAX_APPS; j ++) {
if (p_dev_list->gatt_if[j] == 0 && p_dev_list->listen_gif[j] == 0) {
break;
}
if (p_dev_list->gatt_if[j] == gatt_if) {
for (k = j + 1; k < GATT_MAX_APPS; k ++) {
p_dev_list->gatt_if[k - 1] = p_dev_list->gatt_if[k];
}
if (p_dev_list->gatt_if[0] == 0) {
BTM_BleUpdateBgConnDev(FALSE, p_dev_list->remote_bda);
}
}
if (p_dev_list->listen_gif[j] == gatt_if) {
p_dev_list->listen_gif[j] = 0;
if (p_reg != NULL && p_reg->listening > 0) {
p_reg->listening --;
}
/* move all element behind one forward */
for (k = j + 1; k < GATT_MAX_APPS; k ++) {
p_dev_list->listen_gif[k - 1] = p_dev_list->listen_gif[k];
}
if (p_dev_list->listen_gif[0] == 0) {
BTM_BleUpdateAdvWhitelist(FALSE, p_dev_list->remote_bda);
}
}
}
}
}
}
/*******************************************************************************
**
** Function gatt_reset_bgdev_list
**
** Description reset bg device list
**
** Returns pointer to the device record
**
*******************************************************************************/
void gatt_reset_bgdev_list(void)
{
memset(&gatt_cb.bgconn_dev, 0 , sizeof(tGATT_BG_CONN_DEV)*GATT_MAX_BG_CONN_DEV);
}
/*******************************************************************************
**
** Function gatt_update_auto_connect_dev
**
** Description This function add or remove a device for background connection
** procedure.
**
** Parameters gatt_if: Application ID.
** add: add peer device
** bd_addr: peer device address.
**
** Returns TRUE if connection started; FALSE if connection start failure.
**
*******************************************************************************/
BOOLEAN gatt_update_auto_connect_dev (tGATT_IF gatt_if, BOOLEAN add, BD_ADDR bd_addr, BOOLEAN is_initator)
{
BOOLEAN ret = FALSE;
tGATT_REG *p_reg;
tGATT_TCB *p_tcb = gatt_find_tcb_by_addr(bd_addr, BT_TRANSPORT_LE);
GATT_TRACE_API ("gatt_update_auto_connect_dev ");
/* Make sure app is registered */
if ((p_reg = gatt_get_regcb(gatt_if)) == NULL) {
GATT_TRACE_ERROR("gatt_update_auto_connect_dev - gatt_if %d is not registered", gatt_if);
return (FALSE);
}
if (add) {
ret = gatt_add_bg_dev_list(p_reg, bd_addr, is_initator);
if (ret && p_tcb != NULL) {
/* if a connected device, update the link holding number */
gatt_update_app_use_link_flag(gatt_if, p_tcb, TRUE, TRUE);
}
} else {
ret = gatt_remove_bg_dev_from_list(p_reg, bd_addr, is_initator);
}
return ret;
}
/*******************************************************************************
**
** Function gatt_add_pending_new_srv_start
**
** Description Add a pending new srv start to the new service start queue
**
** Returns Pointer to the new service start buffer, NULL no buffer available
**
*******************************************************************************/
tGATT_PENDING_ENC_CLCB *gatt_add_pending_enc_channel_clcb(tGATT_TCB *p_tcb, tGATT_CLCB *p_clcb )
{
tGATT_PENDING_ENC_CLCB *p_buf;
GATT_TRACE_DEBUG ("gatt_add_pending_new_srv_start");
if ((p_buf = (tGATT_PENDING_ENC_CLCB *)GKI_getbuf((UINT16)sizeof(tGATT_PENDING_ENC_CLCB))) != NULL) {
GATT_TRACE_DEBUG ("enqueue a new pending encryption channel clcb");
p_buf->p_clcb = p_clcb;
GKI_enqueue (&p_tcb->pending_enc_clcb, p_buf);
}
return p_buf;
}
/*******************************************************************************
**
** Function gatt_update_listen_mode
**
** Description update peripheral role listening mode
**
** Returns Pointer to the new service start buffer, NULL no buffer available
**
*******************************************************************************/
BOOLEAN gatt_update_listen_mode(void)
{
UINT8 ii = 0;
tGATT_REG *p_reg = &gatt_cb.cl_rcb[0];
UINT8 listening = 0;
UINT16 connectability, window, interval;
BOOLEAN rt = TRUE;
for (; ii < GATT_MAX_APPS; ii ++, p_reg ++) {
if ( p_reg->in_use && p_reg->listening > listening) {
listening = p_reg->listening;
}
}
if (listening == GATT_LISTEN_TO_ALL ||
listening == GATT_LISTEN_TO_NONE) {
BTM_BleUpdateAdvFilterPolicy (AP_SCAN_CONN_ALL);
} else {
BTM_BleUpdateAdvFilterPolicy (AP_SCAN_CONN_WL);
}
if (rt) {
connectability = BTM_ReadConnectability (&window, &interval);
if (listening != GATT_LISTEN_TO_NONE) {
connectability |= BTM_BLE_CONNECTABLE;
} else {
if ((connectability & BTM_BLE_CONNECTABLE) == 0) {
connectability &= ~BTM_BLE_CONNECTABLE;
}
}
/* turning on the adv now */
btm_ble_set_connectability(connectability);
}
return rt;
}
#endif