1 /******************************************************************************
3 * Copyright (C) 2009-2012 Broadcom Corporation
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
17 ******************************************************************************/
19 /******************************************************************************
21 * this file contains GATT utility functions
23 ******************************************************************************/
24 #include "bt_target.h"
27 #if BLE_INCLUDED == TRUE
30 #include "bt_common.h"
38 /* check if [x, y] and [a, b] have overlapping range */
39 #define GATT_VALIDATE_HANDLE_RANGE(x, y, a, b) (y >= a && x <= b)
41 #define GATT_GET_NEXT_VALID_HANDLE(x) (((x)/10 + 1) * 10)
43 const char * const op_code_name[] =
51 "ATT_REQ_FIND_TYPE_VALUE",
52 "ATT_RSP_FIND_TYPE_VALUE",
53 "ATT_REQ_READ_BY_TYPE",
54 "ATT_RSP_READ_BY_TYPE",
59 "GATT_REQ_READ_MULTI",
60 "GATT_RSP_READ_MULTI",
61 "GATT_REQ_READ_BY_GRP_TYPE",
62 "GATT_RSP_READ_BY_GRP_TYPE",
67 "ATT_REQ_PREPARE_WRITE",
68 "ATT_RSP_PREPARE_WRITE",
72 "ATT_HANDLE_VALUE_NOTIF",
74 "ATT_HANDLE_VALUE_IND",
75 "ATT_HANDLE_VALUE_CONF",
79 static const UINT8 base_uuid[LEN_UUID_128] = {0xFB, 0x34, 0x9B, 0x5F, 0x80, 0x00, 0x00, 0x80,
80 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
82 extern fixed_queue_t *btu_general_alarm_queue;
84 /*******************************************************************************
86 ** Function gatt_free_pending_ind
88 ** Description Free all pending indications
92 *******************************************************************************/
93 void gatt_free_pending_ind(tGATT_TCB *p_tcb)
95 GATT_TRACE_DEBUG("%s", __func__);
97 if (p_tcb->pending_ind_q == NULL)
100 /* release all queued indications */
101 while (!fixed_queue_is_empty(p_tcb->pending_ind_q))
102 osi_free(fixed_queue_try_dequeue(p_tcb->pending_ind_q));
103 fixed_queue_free(p_tcb->pending_ind_q, NULL);
104 p_tcb->pending_ind_q = NULL;
107 /*******************************************************************************
109 ** Function gatt_free_pending_enc_queue
111 ** Description Free all buffers in pending encyption queue
115 *******************************************************************************/
116 void gatt_free_pending_enc_queue(tGATT_TCB *p_tcb)
118 GATT_TRACE_DEBUG("%s", __func__);
120 if (p_tcb->pending_enc_clcb == NULL)
123 /* release all queued indications */
124 while (!fixed_queue_is_empty(p_tcb->pending_enc_clcb))
125 osi_free(fixed_queue_try_dequeue(p_tcb->pending_enc_clcb));
126 fixed_queue_free(p_tcb->pending_enc_clcb, NULL);
127 p_tcb->pending_enc_clcb = NULL;
130 /*******************************************************************************
132 ** Function gatt_delete_dev_from_srv_chg_clt_list
134 ** Description Delete a device from the service changed client lit
138 *******************************************************************************/
139 void gatt_delete_dev_from_srv_chg_clt_list(BD_ADDR bd_addr)
141 GATT_TRACE_DEBUG("gatt_delete_dev_from_srv_chg_clt_list");
143 tGATTS_SRV_CHG *p_buf = gatt_is_bda_in_the_srv_chg_clt_list(bd_addr);
146 if (gatt_cb.cb_info.p_srv_chg_callback)
149 tGATTS_SRV_CHG_REQ req;
150 memcpy(req.srv_chg.bda, bd_addr, BD_ADDR_LEN);
151 (*gatt_cb.cb_info.p_srv_chg_callback)(GATTS_SRV_CHG_CMD_REMOVE_CLIENT,&req, NULL);
153 osi_free(fixed_queue_try_remove_from_queue(gatt_cb.srv_chg_clt_q,
158 /*******************************************************************************
160 ** Function gatt_set_srv_chg
162 ** Description Set the service changed flag to TRUE
166 *******************************************************************************/
167 void gatt_set_srv_chg(void)
169 GATT_TRACE_DEBUG ("gatt_set_srv_chg");
171 if (fixed_queue_is_empty(gatt_cb.srv_chg_clt_q))
174 list_t *list = fixed_queue_get_list(gatt_cb.srv_chg_clt_q);
175 for (const list_node_t *node = list_begin(list); node != list_end(list);
176 node = list_next(node)) {
177 GATT_TRACE_DEBUG ("found a srv_chg clt");
179 tGATTS_SRV_CHG *p_buf = (tGATTS_SRV_CHG *)list_node(node);
180 if (!p_buf->srv_changed)
182 GATT_TRACE_DEBUG("set srv_changed to TRUE");
183 p_buf->srv_changed = TRUE;
184 tGATTS_SRV_CHG_REQ req;
185 memcpy(&req.srv_chg, p_buf, sizeof(tGATTS_SRV_CHG));
186 if (gatt_cb.cb_info.p_srv_chg_callback)
187 (*gatt_cb.cb_info.p_srv_chg_callback)(GATTS_SRV_CHG_CMD_UPDATE_CLIENT,&req, NULL);
192 /*******************************************************************************
194 ** Function gatt_sr_is_new_srv_chg
196 ** Description Find the app id in on the new service changed list
198 ** Returns Pointer to the found new service changed item othwerwise NULL
200 *******************************************************************************/
201 tGATTS_PENDING_NEW_SRV_START *gatt_sr_is_new_srv_chg(tBT_UUID *p_app_uuid128, tBT_UUID *p_svc_uuid, UINT16 svc_inst)
203 tGATTS_PENDING_NEW_SRV_START *p_buf = NULL;
205 if (fixed_queue_is_empty(gatt_cb.pending_new_srv_start_q))
208 list_t *list = fixed_queue_get_list(gatt_cb.pending_new_srv_start_q);
209 for (const list_node_t *node = list_begin(list); node != list_end(list);
210 node = list_next(node)) {
211 p_buf = (tGATTS_PENDING_NEW_SRV_START *)list_node(node);
212 tGATTS_HNDL_RANGE *p = p_buf->p_new_srv_start;
213 if (gatt_uuid_compare(*p_app_uuid128, p->app_uuid128)
214 && gatt_uuid_compare (*p_svc_uuid, p->svc_uuid)
215 && (svc_inst == p->svc_inst)) {
216 GATT_TRACE_DEBUG("gatt_sr_is_new_srv_chg: Yes");
225 /*******************************************************************************
227 ** Function gatt_add_pending_ind
229 ** Description Add a pending indication
231 ** Returns Pointer to the current pending indication buffer, NULL no buffer available
233 *******************************************************************************/
234 tGATT_VALUE *gatt_add_pending_ind(tGATT_TCB *p_tcb, tGATT_VALUE *p_ind)
236 tGATT_VALUE *p_buf = (tGATT_VALUE *)osi_malloc(sizeof(tGATT_VALUE));
238 GATT_TRACE_DEBUG("%s", __func__);
239 GATT_TRACE_DEBUG("enqueue a pending indication");
241 memcpy(p_buf, p_ind, sizeof(tGATT_VALUE));
242 fixed_queue_enqueue(p_tcb->pending_ind_q, p_buf);
247 /*******************************************************************************
249 ** Function gatt_add_pending_new_srv_start
251 ** Description Add a pending new srv start to the new service start queue
253 ** Returns Pointer to the new service start buffer, NULL no buffer available
255 *******************************************************************************/
256 tGATTS_PENDING_NEW_SRV_START *gatt_add_pending_new_srv_start(tGATTS_HNDL_RANGE *p_new_srv_start)
258 tGATTS_PENDING_NEW_SRV_START *p_buf =
259 (tGATTS_PENDING_NEW_SRV_START *)osi_malloc(sizeof(tGATTS_PENDING_NEW_SRV_START));
261 GATT_TRACE_DEBUG("%s", __func__);
262 GATT_TRACE_DEBUG("enqueue a new pending new srv start");
264 p_buf->p_new_srv_start = p_new_srv_start;
265 fixed_queue_enqueue(gatt_cb.pending_new_srv_start_q, p_buf);
271 /*******************************************************************************
273 ** Function gatt_add_srv_chg_clt
275 ** Description Add a service chnage client to the service change client queue
277 ** Returns Pointer to the service change client buffer; Null no buffer available
279 *******************************************************************************/
280 tGATTS_SRV_CHG *gatt_add_srv_chg_clt(tGATTS_SRV_CHG *p_srv_chg)
282 tGATTS_SRV_CHG *p_buf = (tGATTS_SRV_CHG *)osi_malloc(sizeof(tGATTS_SRV_CHG));
284 GATT_TRACE_DEBUG("%s", __func__);
285 GATT_TRACE_DEBUG("enqueue a srv chg client");
287 memcpy(p_buf, p_srv_chg, sizeof(tGATTS_SRV_CHG));
288 fixed_queue_enqueue(gatt_cb.srv_chg_clt_q, p_buf);
293 /*******************************************************************************
295 ** Function gatt_alloc_hdl_buffer
297 ** Description Allocate a handle buufer
299 ** Returns Pointer to the allocated buffer, NULL no buffer available
301 *******************************************************************************/
302 tGATT_HDL_LIST_ELEM *gatt_alloc_hdl_buffer(void)
305 tGATT_CB *p_cb = &gatt_cb;
306 tGATT_HDL_LIST_ELEM * p_elem= &p_cb->hdl_list[0];
308 for (i = 0; i < GATT_MAX_SR_PROFILES; i++, p_elem++)
310 if (!p_cb->hdl_list[i].in_use)
312 memset(p_elem, 0, sizeof(tGATT_HDL_LIST_ELEM));
313 p_elem->in_use = TRUE;
314 p_elem->svc_db.svc_buffer = fixed_queue_new(SIZE_MAX);
322 /*******************************************************************************
324 ** Function gatt_find_hdl_buffer_by_handle
326 ** Description Find handle range buffer by service handle.
328 ** Returns Pointer to the buffer, NULL no buffer available
330 *******************************************************************************/
331 tGATT_HDL_LIST_ELEM *gatt_find_hdl_buffer_by_handle(UINT16 handle)
333 tGATT_HDL_LIST_INFO *p_list_info= &gatt_cb.hdl_list_info;
334 tGATT_HDL_LIST_ELEM *p_list = NULL;
336 p_list = p_list_info->p_first;
338 while (p_list != NULL)
340 if (p_list->in_use && p_list->asgn_range.s_handle == handle)
344 p_list = p_list->p_next;
348 /*******************************************************************************
350 ** Function gatt_find_hdl_buffer_by_app_id
352 ** Description Find handle range buffer by app ID, service and service instance ID.
354 ** Returns Pointer to the buffer, NULL no buffer available
356 *******************************************************************************/
357 tGATT_HDL_LIST_ELEM *gatt_find_hdl_buffer_by_app_id (tBT_UUID *p_app_uuid128,
358 tBT_UUID *p_svc_uuid,
361 tGATT_HDL_LIST_INFO *p_list_info= &gatt_cb.hdl_list_info;
362 tGATT_HDL_LIST_ELEM *p_list = NULL;
364 p_list = p_list_info->p_first;
366 while (p_list != NULL)
368 if ( gatt_uuid_compare (*p_app_uuid128, p_list->asgn_range.app_uuid128)
369 && gatt_uuid_compare (*p_svc_uuid, p_list->asgn_range.svc_uuid)
370 && (svc_inst == p_list->asgn_range.svc_inst) )
372 GATT_TRACE_DEBUG ("Already allocated handles for this service before!!");
375 p_list = p_list->p_next;
379 /*******************************************************************************
381 ** Function gatt_free_hdl_buffer
383 ** Description free a handle buffer
387 *******************************************************************************/
388 void gatt_free_hdl_buffer(tGATT_HDL_LIST_ELEM *p)
393 while (!fixed_queue_is_empty(p->svc_db.svc_buffer))
394 osi_free(fixed_queue_try_dequeue(p->svc_db.svc_buffer));
395 fixed_queue_free(p->svc_db.svc_buffer, NULL);
396 memset(p, 0, sizeof(tGATT_HDL_LIST_ELEM));
399 /*******************************************************************************
401 ** Function gatt_free_srvc_db_buffer_app_id
403 ** Description free the service attribute database buffers by the owner of the
408 *******************************************************************************/
409 void gatt_free_srvc_db_buffer_app_id(tBT_UUID *p_app_id)
411 tGATT_HDL_LIST_ELEM *p_elem = &gatt_cb.hdl_list[0];
414 for (i = 0; i < GATT_MAX_SR_PROFILES; i ++, p_elem ++)
416 if (memcmp(p_app_id, &p_elem->asgn_range.app_uuid128, sizeof(tBT_UUID)) == 0)
418 while (!fixed_queue_is_empty(p_elem->svc_db.svc_buffer))
419 osi_free(fixed_queue_try_dequeue(p_elem->svc_db.svc_buffer));
420 fixed_queue_free(p_elem->svc_db.svc_buffer, NULL);
421 p_elem->svc_db.svc_buffer = NULL;
423 p_elem->svc_db.mem_free = 0;
424 p_elem->svc_db.p_attr_list = p_elem->svc_db.p_free_mem = NULL;
428 /*******************************************************************************
430 ** Function gatt_is_last_attribute
432 ** Description Check this is the last attribute of the specified value or not
434 ** Returns TRUE - yes this is the last attribute
436 *******************************************************************************/
437 BOOLEAN gatt_is_last_attribute(tGATT_SRV_LIST_INFO *p_list, tGATT_SRV_LIST_ELEM *p_start, tBT_UUID value)
439 tGATT_SRV_LIST_ELEM *p_srv= p_start->p_next;
440 BOOLEAN is_last_attribute = TRUE;
441 tGATT_SR_REG *p_rcb = NULL;
442 tBT_UUID *p_svc_uuid;
444 p_list->p_last_primary = NULL;
448 p_rcb = GATT_GET_SR_REG_PTR(p_srv->i_sreg);
450 p_svc_uuid = gatts_get_service_uuid (p_rcb->p_db);
452 if (gatt_uuid_compare(value, *p_svc_uuid))
454 is_last_attribute = FALSE;
458 p_srv = p_srv->p_next;
461 return is_last_attribute;
465 /*******************************************************************************
467 ** Function gatt_update_last_pri_srv_info
469 ** Description Update the the last primary info for the service list info
473 *******************************************************************************/
474 void gatt_update_last_pri_srv_info(tGATT_SRV_LIST_INFO *p_list)
476 tGATT_SRV_LIST_ELEM *p_srv= p_list->p_first;
478 p_list->p_last_primary = NULL;
482 if (p_srv->is_primary)
484 p_list->p_last_primary = p_srv;
486 p_srv = p_srv->p_next;
490 /*******************************************************************************
492 ** Function gatts_update_srv_list_elem
494 ** Description update an element in the service list.
498 *******************************************************************************/
499 void gatts_update_srv_list_elem(UINT8 i_sreg, UINT16 handle, BOOLEAN is_primary)
503 gatt_cb.srv_list[i_sreg].in_use = TRUE;
504 gatt_cb.srv_list[i_sreg].i_sreg = i_sreg;
505 gatt_cb.srv_list[i_sreg].s_hdl = gatt_cb.sr_reg[i_sreg].s_hdl;
506 gatt_cb.srv_list[i_sreg].is_primary = is_primary;
510 /*******************************************************************************
512 ** Function gatt_add_a_srv_to_list
514 ** Description add an service to the list in ascending
515 ** order of the start handle
517 ** Returns BOOLEAN TRUE-if add is successful
519 *******************************************************************************/
520 BOOLEAN gatt_add_a_srv_to_list(tGATT_SRV_LIST_INFO *p_list, tGATT_SRV_LIST_ELEM *p_new)
522 tGATT_SRV_LIST_ELEM *p_old;
526 GATT_TRACE_DEBUG("p_new==NULL");
530 if (!p_list->p_first)
532 /* this is an empty list */
534 p_list->p_last = p_new;
536 p_new->p_prev = NULL;
540 p_old = p_list->p_first;
545 p_list->p_last->p_next = p_new;
546 p_new->p_prev = p_list->p_last;
547 p_new->p_next = NULL;
548 p_list->p_last = p_new;
553 if (p_new->s_hdl < p_old->s_hdl)
555 /* if not the first in list */
556 if (p_old->p_prev != NULL)
557 p_old->p_prev->p_next = p_new;
559 p_list->p_first = p_new;
561 p_new->p_prev = p_old->p_prev;
562 p_new->p_next = p_old;
563 p_old->p_prev = p_new;
567 p_old = p_old->p_next;
572 gatt_update_last_pri_srv_info(p_list);
577 /*******************************************************************************
579 ** Function gatt_remove_a_srv_from_list
581 ** Description Remove a service from the list
583 ** Returns BOOLEAN TRUE-if remove is successful
585 *******************************************************************************/
586 BOOLEAN gatt_remove_a_srv_from_list(tGATT_SRV_LIST_INFO *p_list, tGATT_SRV_LIST_ELEM *p_remove)
588 if (!p_remove || !p_list->p_first)
590 GATT_TRACE_DEBUG("p_remove==NULL || p_list->p_first==NULL");
594 if (p_remove->p_prev == NULL)
596 p_list->p_first = p_remove->p_next;
597 if (p_remove->p_next)
598 p_remove->p_next->p_prev = NULL;
600 else if (p_remove->p_next == NULL)
602 p_list->p_last = p_remove->p_prev;
603 p_remove->p_prev->p_next = NULL;
607 p_remove->p_next->p_prev = p_remove->p_prev;
608 p_remove->p_prev->p_next = p_remove->p_next;
611 gatt_update_last_pri_srv_info(p_list);
616 /*******************************************************************************
618 ** Function gatt_add_an_item_to_list
620 ** Description add an service handle range to the list in decending
621 ** order of the start handle
623 ** Returns BOOLEAN TRUE-if add is successful
625 *******************************************************************************/
626 BOOLEAN gatt_add_an_item_to_list(tGATT_HDL_LIST_INFO *p_list, tGATT_HDL_LIST_ELEM *p_new)
628 tGATT_HDL_LIST_ELEM *p_old;
631 GATT_TRACE_DEBUG("p_new==NULL");
635 if (!p_list->p_first)
637 /* this is an empty list */
639 p_list->p_last = p_new;
641 p_new->p_prev = NULL;
645 p_old = p_list->p_first;
650 p_list->p_last->p_next = p_new;
651 p_new->p_prev = p_list->p_last;
652 p_new->p_next = NULL;
653 p_list->p_last = p_new;
660 if (p_new->asgn_range.s_handle > p_old->asgn_range.s_handle)
662 if (p_old == p_list->p_first)
663 p_list->p_first = p_new;
665 p_new->p_prev = p_old->p_prev;
666 p_new->p_next = p_old;
669 p_old->p_prev = p_new;
673 p_old = p_old->p_next;
681 /*******************************************************************************
683 ** Function gatt_remove_an_item_from_list
685 ** Description Remove an service handle range from the list
687 ** Returns BOOLEAN TRUE-if remove is successful
689 *******************************************************************************/
690 BOOLEAN gatt_remove_an_item_from_list(tGATT_HDL_LIST_INFO *p_list, tGATT_HDL_LIST_ELEM *p_remove)
692 if (!p_remove || !p_list->p_first)
694 GATT_TRACE_DEBUG("p_remove==NULL || p_list->p_first==NULL");
698 if (p_remove->p_prev == NULL)
700 p_list->p_first = p_remove->p_next;
701 if (p_remove->p_next)
702 p_remove->p_next->p_prev = NULL;
704 else if (p_remove->p_next == NULL)
706 p_list->p_last = p_remove->p_prev;
707 p_remove->p_prev->p_next = NULL;
711 p_remove->p_next->p_prev = p_remove->p_prev;
712 p_remove->p_prev->p_next = p_remove->p_next;
719 /*******************************************************************************
721 ** Function gatt_find_the_connected_bda
723 ** Description This function find the connected bda
725 ** Returns TRUE if found
727 *******************************************************************************/
728 BOOLEAN gatt_find_the_connected_bda(UINT8 start_idx, BD_ADDR bda, UINT8 *p_found_idx,
729 tBT_TRANSPORT *p_transport)
732 BOOLEAN found = FALSE;
733 GATT_TRACE_DEBUG("gatt_find_the_connected_bda start_idx=%d",start_idx);
735 for (i = start_idx ; i < GATT_MAX_PHY_CHANNEL; i ++)
737 if (gatt_cb.tcb[i].in_use && gatt_cb.tcb[i].ch_state == GATT_CH_OPEN)
739 memcpy( bda, gatt_cb.tcb[i].peer_bda, BD_ADDR_LEN);
741 *p_transport = gatt_cb.tcb[i].transport;
743 GATT_TRACE_DEBUG("gatt_find_the_connected_bda bda :%02x-%02x-%02x-%02x-%02x-%02x",
744 bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
748 GATT_TRACE_DEBUG("gatt_find_the_connected_bda found=%d found_idx=%d", found, i);
754 /*******************************************************************************
756 ** Function gatt_is_srv_chg_ind_pending
758 ** Description Check whether a service chnaged is in the indication pending queue
759 ** or waiting for an Ack already
763 *******************************************************************************/
764 BOOLEAN gatt_is_srv_chg_ind_pending (tGATT_TCB *p_tcb)
766 BOOLEAN srv_chg_ind_pending = FALSE;
768 GATT_TRACE_DEBUG("gatt_is_srv_chg_ind_pending is_queue_empty=%d",
769 fixed_queue_is_empty(p_tcb->pending_ind_q));
771 if (p_tcb->indicate_handle == gatt_cb.handle_of_h_r)
773 srv_chg_ind_pending = TRUE;
775 else if (! fixed_queue_is_empty(p_tcb->pending_ind_q))
777 list_t *list = fixed_queue_get_list(p_tcb->pending_ind_q);
778 for (const list_node_t *node = list_begin(list);
779 node != list_end(list);
780 node = list_next(node)) {
781 tGATT_VALUE *p_buf = (tGATT_VALUE *)list_node(node);
782 if (p_buf->handle == gatt_cb.handle_of_h_r)
784 srv_chg_ind_pending = TRUE;
790 GATT_TRACE_DEBUG("srv_chg_ind_pending = %d", srv_chg_ind_pending);
791 return srv_chg_ind_pending;
795 /*******************************************************************************
797 ** Function gatt_is_bda_in_the_srv_chg_clt_list
799 ** Description This function check the specified bda is in the srv chg clinet list or not
801 ** Returns pointer to the found elemenet otherwise NULL
803 *******************************************************************************/
804 tGATTS_SRV_CHG *gatt_is_bda_in_the_srv_chg_clt_list (BD_ADDR bda)
806 tGATTS_SRV_CHG *p_buf = NULL;
808 GATT_TRACE_DEBUG("gatt_is_bda_in_the_srv_chg_clt_list :%02x-%02x-%02x-%02x-%02x-%02x",
809 bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
811 if (fixed_queue_is_empty(gatt_cb.srv_chg_clt_q))
814 list_t *list = fixed_queue_get_list(gatt_cb.srv_chg_clt_q);
815 for (const list_node_t *node = list_begin(list); node != list_end(list);
816 node = list_next(node)) {
817 tGATTS_SRV_CHG *p_buf = (tGATTS_SRV_CHG *)list_node(node);
818 if (!memcmp( bda, p_buf->bda, BD_ADDR_LEN))
820 GATT_TRACE_DEBUG("bda is in the srv chg clt list");
829 /*******************************************************************************
831 ** Function gatt_is_bda_connected
835 ** Returns GATT_INDEX_INVALID if not found. Otherwise index to the tcb.
837 *******************************************************************************/
838 BOOLEAN gatt_is_bda_connected(BD_ADDR bda)
841 BOOLEAN connected=FALSE;
843 for ( i=0; i < GATT_MAX_PHY_CHANNEL; i ++)
845 if (gatt_cb.tcb[i].in_use &&
846 !memcmp(gatt_cb.tcb[i].peer_bda, bda, BD_ADDR_LEN))
855 /*******************************************************************************
857 ** Function gatt_find_i_tcb_by_addr
859 ** Description The function searches for an empty tcb entry, and return the index.
861 ** Returns GATT_INDEX_INVALID if not found. Otherwise index to the tcb.
863 *******************************************************************************/
864 UINT8 gatt_find_i_tcb_by_addr(BD_ADDR bda, tBT_TRANSPORT transport)
868 for ( ; i < GATT_MAX_PHY_CHANNEL; i ++)
870 if (!memcmp(gatt_cb.tcb[i].peer_bda, bda, BD_ADDR_LEN) &&
871 gatt_cb.tcb[i].transport == transport)
876 return GATT_INDEX_INVALID;
880 /*******************************************************************************
882 ** Function gatt_get_tcb_by_idx
884 ** Description The function get TCB using the TCB index
886 ** Returns NULL if not found. Otherwise index to the tcb.
888 *******************************************************************************/
889 tGATT_TCB * gatt_get_tcb_by_idx(UINT8 tcb_idx)
891 tGATT_TCB *p_tcb = NULL;
893 if ( (tcb_idx < GATT_MAX_PHY_CHANNEL) && gatt_cb.tcb[tcb_idx].in_use)
894 p_tcb = &gatt_cb.tcb[tcb_idx];
899 /*******************************************************************************
901 ** Function gatt_find_tcb_by_addr
903 ** Description The function searches for an empty tcb entry, and return pointer.
905 ** Returns NULL if not found. Otherwise index to the tcb.
907 *******************************************************************************/
908 tGATT_TCB * gatt_find_tcb_by_addr(BD_ADDR bda, tBT_TRANSPORT transport)
910 tGATT_TCB *p_tcb = NULL;
913 if ((i = gatt_find_i_tcb_by_addr(bda, transport)) != GATT_INDEX_INVALID)
914 p_tcb = &gatt_cb.tcb[i];
918 /*******************************************************************************
920 ** Function gatt_find_i_tcb_free
922 ** Description The function searches for an empty tcb entry, and return the index.
924 ** Returns GATT_INDEX_INVALID if not found. Otherwise index to the tcb.
926 *******************************************************************************/
927 UINT8 gatt_find_i_tcb_free(void)
929 UINT8 i = 0, j = GATT_INDEX_INVALID;
931 for (i = 0; i < GATT_MAX_PHY_CHANNEL; i ++)
933 if (!gatt_cb.tcb[i].in_use)
941 /*******************************************************************************
943 ** Function gatt_allocate_tcb_by_bdaddr
945 ** Description The function locate or allocate new tcb entry for matching bda.
947 ** Returns GATT_INDEX_INVALID if not found. Otherwise index to the tcb.
949 *******************************************************************************/
950 tGATT_TCB * gatt_allocate_tcb_by_bdaddr(BD_ADDR bda, tBT_TRANSPORT transport)
953 BOOLEAN allocated = FALSE;
954 tGATT_TCB *p_tcb = NULL;
956 /* search for existing tcb with matching bda */
957 i = gatt_find_i_tcb_by_addr(bda, transport);
959 if (i == GATT_INDEX_INVALID)
961 i = gatt_find_i_tcb_free();
964 if (i != GATT_INDEX_INVALID)
966 p_tcb = &gatt_cb.tcb[i];
970 memset(p_tcb, 0, sizeof(tGATT_TCB));
971 p_tcb->pending_enc_clcb = fixed_queue_new(SIZE_MAX);
972 p_tcb->pending_ind_q = fixed_queue_new(SIZE_MAX);
973 p_tcb->conf_timer = alarm_new("gatt.conf_timer");
974 p_tcb->ind_ack_timer = alarm_new("gatt.ind_ack_timer");
975 p_tcb->sr_cmd.multi_rsp_q = fixed_queue_new(SIZE_MAX);
976 p_tcb->in_use = TRUE;
978 p_tcb->transport = transport;
980 memcpy(p_tcb->peer_bda, bda, BD_ADDR_LEN);
985 /*******************************************************************************
987 ** Function gatt_convert_uuid16_to_uuid128
989 ** Description Convert a 16 bits UUID to be an standard 128 bits one.
991 ** Returns TRUE if two uuid match; FALSE otherwise.
993 *******************************************************************************/
994 void gatt_convert_uuid16_to_uuid128(UINT8 uuid_128[LEN_UUID_128], UINT16 uuid_16)
996 UINT8 *p = &uuid_128[LEN_UUID_128 - 4];
998 memcpy (uuid_128, base_uuid, LEN_UUID_128);
1000 UINT16_TO_STREAM(p, uuid_16);
1003 /*******************************************************************************
1005 ** Function gatt_convert_uuid32_to_uuid128
1007 ** Description Convert a 32 bits UUID to be an standard 128 bits one.
1009 ** Returns TRUE if two uuid match; FALSE otherwise.
1011 *******************************************************************************/
1012 void gatt_convert_uuid32_to_uuid128(UINT8 uuid_128[LEN_UUID_128], UINT32 uuid_32)
1014 UINT8 *p = &uuid_128[LEN_UUID_128 - 4];
1016 memcpy (uuid_128, base_uuid, LEN_UUID_128);
1018 UINT32_TO_STREAM(p, uuid_32);
1020 /*******************************************************************************
1022 ** Function gatt_uuid_compare
1024 ** Description Compare two UUID to see if they are the same.
1026 ** Returns TRUE if two uuid match; FALSE otherwise.
1028 *******************************************************************************/
1029 BOOLEAN gatt_uuid_compare (tBT_UUID src, tBT_UUID tar)
1031 UINT8 su[LEN_UUID_128], tu[LEN_UUID_128];
1034 /* any of the UUID is unspecified */
1035 if (src.len == 0 || tar.len == 0)
1040 /* If both are 16-bit, we can do a simple compare */
1041 if (src.len == LEN_UUID_16 && tar.len == LEN_UUID_16)
1043 return src.uu.uuid16 == tar.uu.uuid16;
1046 /* If both are 32-bit, we can do a simple compare */
1047 if (src.len == LEN_UUID_32 && tar.len == LEN_UUID_32)
1049 return src.uu.uuid32 == tar.uu.uuid32;
1052 /* One or both of the UUIDs is 128-bit */
1053 if (src.len == LEN_UUID_16)
1055 /* convert a 16 bits UUID to 128 bits value */
1056 gatt_convert_uuid16_to_uuid128(su, src.uu.uuid16);
1059 else if (src.len == LEN_UUID_32)
1061 gatt_convert_uuid32_to_uuid128(su, src.uu.uuid32);
1065 ps = src.uu.uuid128;
1067 if (tar.len == LEN_UUID_16)
1069 /* convert a 16 bits UUID to 128 bits value */
1070 gatt_convert_uuid16_to_uuid128(tu, tar.uu.uuid16);
1073 else if (tar.len == LEN_UUID_32)
1075 /* convert a 32 bits UUID to 128 bits value */
1076 gatt_convert_uuid32_to_uuid128(tu, tar.uu.uuid32);
1080 pt = tar.uu.uuid128;
1082 return(memcmp(ps, pt, LEN_UUID_128) == 0);
1085 /*******************************************************************************
1087 ** Function gatt_build_uuid_to_stream
1089 ** Description Add UUID into stream.
1091 ** Returns UUID length.
1093 *******************************************************************************/
1094 UINT8 gatt_build_uuid_to_stream(UINT8 **p_dst, tBT_UUID uuid)
1099 if (uuid.len == LEN_UUID_16)
1101 UINT16_TO_STREAM (p, uuid.uu.uuid16);
1104 else if (uuid.len == LEN_UUID_32) /* always convert 32 bits into 128 bits as alwats */
1106 gatt_convert_uuid32_to_uuid128(p, uuid.uu.uuid32);
1110 else if (uuid.len == LEN_UUID_128)
1112 ARRAY_TO_STREAM (p, uuid.uu.uuid128, LEN_UUID_128);
1120 /*******************************************************************************
1122 ** Function gatt_parse_uuid_from_cmd
1124 ** Description Convert a 128 bits UUID into a 16 bits UUID.
1126 ** Returns TRUE if command sent, otherwise FALSE.
1128 *******************************************************************************/
1129 BOOLEAN gatt_parse_uuid_from_cmd(tBT_UUID *p_uuid_rec, UINT16 uuid_size, UINT8 **p_data)
1131 BOOLEAN is_base_uuid, ret = TRUE;
1133 UINT8 *p_uuid = *p_data;
1135 memset(p_uuid_rec, 0, sizeof(tBT_UUID));
1140 p_uuid_rec->len = uuid_size;
1141 STREAM_TO_UINT16 (p_uuid_rec->uu.uuid16, p_uuid);
1142 *p_data += LEN_UUID_16;
1146 /* See if we can compress his UUID down to 16 or 32bit UUIDs */
1147 is_base_uuid = TRUE;
1148 for (xx = 0; xx < LEN_UUID_128 - 4; xx++)
1150 if (p_uuid[xx] != base_uuid[xx])
1152 is_base_uuid = FALSE;
1158 if ((p_uuid[LEN_UUID_128 - 1] == 0) && (p_uuid[LEN_UUID_128 - 2] == 0))
1160 p_uuid += (LEN_UUID_128 - 4);
1161 p_uuid_rec->len = LEN_UUID_16;
1162 STREAM_TO_UINT16(p_uuid_rec->uu.uuid16, p_uuid);
1166 p_uuid += (LEN_UUID_128 - LEN_UUID_32);
1167 p_uuid_rec->len = LEN_UUID_32;
1168 STREAM_TO_UINT32(p_uuid_rec->uu.uuid32, p_uuid);
1173 p_uuid_rec->len = LEN_UUID_128;
1174 memcpy(p_uuid_rec->uu.uuid128, p_uuid, LEN_UUID_128);
1176 *p_data += LEN_UUID_128;
1179 /* do not allow 32 bits UUID in ATT PDU now */
1181 GATT_TRACE_ERROR("DO NOT ALLOW 32 BITS UUID IN ATT PDU");
1184 if (uuid_size != 0) ret = FALSE;
1185 GATT_TRACE_WARNING("gatt_parse_uuid_from_cmd invalid uuid size");
1192 /*******************************************************************************
1194 ** Function gatt_start_rsp_timer
1196 ** Description Start a wait_for_response timer.
1200 *******************************************************************************/
1201 void gatt_start_rsp_timer(UINT16 clcb_idx)
1203 tGATT_CLCB *p_clcb = &gatt_cb.clcb[clcb_idx];
1204 period_ms_t timeout_ms = GATT_WAIT_FOR_RSP_TIMEOUT_MS;
1206 if (p_clcb->operation == GATTC_OPTYPE_DISCOVERY &&
1207 p_clcb->op_subtype == GATT_DISC_SRVC_ALL) {
1208 timeout_ms = GATT_WAIT_FOR_DISC_RSP_TIMEOUT_MS;
1211 // TODO: The tGATT_CLCB memory and state management needs cleanup,
1212 // and then the timers can be allocated elsewhere.
1213 if (p_clcb->gatt_rsp_timer_ent == NULL) {
1214 p_clcb->gatt_rsp_timer_ent = alarm_new("gatt.gatt_rsp_timer_ent");
1216 alarm_set_on_queue(p_clcb->gatt_rsp_timer_ent, timeout_ms,
1217 gatt_rsp_timeout, p_clcb, btu_general_alarm_queue);
1220 /*******************************************************************************
1222 ** Function gatt_start_conf_timer
1224 ** Description Start a wait_for_confirmation timer.
1228 *******************************************************************************/
1229 void gatt_start_conf_timer(tGATT_TCB *p_tcb)
1231 alarm_set_on_queue(p_tcb->conf_timer, GATT_WAIT_FOR_RSP_TIMEOUT_MS,
1232 gatt_indication_confirmation_timeout, p_tcb,
1233 btu_general_alarm_queue);
1236 /*******************************************************************************
1238 ** Function gatt_start_ind_ack_timer
1240 ** Description start the application ack timer
1244 *******************************************************************************/
1245 void gatt_start_ind_ack_timer(tGATT_TCB *p_tcb)
1247 /* start notification cache timer */
1248 alarm_set_on_queue(p_tcb->ind_ack_timer, GATT_WAIT_FOR_RSP_TIMEOUT_MS,
1249 gatt_ind_ack_timeout, p_tcb, btu_general_alarm_queue);
1252 /*******************************************************************************
1254 ** Function gatt_rsp_timeout
1256 ** Description Called when GATT wait for ATT command response timer expires
1260 *******************************************************************************/
1261 void gatt_rsp_timeout(void *data)
1263 tGATT_CLCB *p_clcb = (tGATT_CLCB *)data;
1265 if (p_clcb == NULL || p_clcb->p_tcb == NULL)
1267 GATT_TRACE_WARNING("%s clcb is already deleted", __func__);
1270 if (p_clcb->operation == GATTC_OPTYPE_DISCOVERY &&
1271 p_clcb->op_subtype == GATT_DISC_SRVC_ALL &&
1272 p_clcb->retry_count < GATT_REQ_RETRY_LIMIT)
1275 GATT_TRACE_WARNING("%s retry discovery primary service", __func__);
1276 if (p_clcb != gatt_cmd_dequeue(p_clcb->p_tcb, &rsp_code))
1278 GATT_TRACE_ERROR("%s command queue out of sync, disconnect",
1283 p_clcb->retry_count++;
1284 gatt_act_discovery(p_clcb);
1289 GATT_TRACE_WARNING("%s disconnecting...", __func__);
1290 gatt_disconnect (p_clcb->p_tcb);
1293 /*******************************************************************************
1295 ** Function gatt_indication_confirmation_timeout
1297 ** Description Called when the indication confirmation timer expires
1301 *******************************************************************************/
1302 void gatt_indication_confirmation_timeout(void *data)
1304 tGATT_TCB *p_tcb = (tGATT_TCB *)data;
1306 GATT_TRACE_WARNING("%s disconnecting...", __func__);
1307 gatt_disconnect(p_tcb);
1310 /*******************************************************************************
1312 ** Function gatt_ind_ack_timeout
1314 ** Description Called when GATT wait for ATT handle confirmation timeout
1318 *******************************************************************************/
1319 void gatt_ind_ack_timeout(void *data)
1321 tGATT_TCB *p_tcb = (tGATT_TCB *)data;
1323 GATT_TRACE_WARNING("%s send ack now", __func__);
1326 p_tcb->ind_count = 0;
1328 attp_send_cl_msg(p_tcb, 0, GATT_HANDLE_VALUE_CONF, NULL);
1330 /*******************************************************************************
1332 ** Function gatt_sr_find_i_rcb_by_handle
1334 ** Description The function searches for a service that owns a specific handle.
1336 ** Returns GATT_MAX_SR_PROFILES if not found. Otherwise index of th eservice.
1338 *******************************************************************************/
1339 UINT8 gatt_sr_find_i_rcb_by_handle(UINT16 handle)
1343 for ( ; i_rcb < GATT_MAX_SR_PROFILES; i_rcb++)
1345 if (gatt_cb.sr_reg[i_rcb].in_use &&
1346 gatt_cb.sr_reg[i_rcb].s_hdl <= handle &&
1347 gatt_cb.sr_reg[i_rcb].e_hdl >= handle )
1355 /*******************************************************************************
1357 ** Function gatt_sr_find_i_rcb_by_handle
1359 ** Description The function searches for a service that owns a specific handle.
1361 ** Returns 0 if not found. Otherwise index of th eservice.
1363 *******************************************************************************/
1364 UINT8 gatt_sr_find_i_rcb_by_app_id(tBT_UUID *p_app_uuid128, tBT_UUID *p_svc_uuid, UINT16 svc_inst)
1367 tGATT_SR_REG *p_sreg;
1368 tBT_UUID *p_this_uuid;
1370 for (i_rcb = 0, p_sreg = gatt_cb.sr_reg; i_rcb < GATT_MAX_SR_PROFILES; i_rcb++, p_sreg++)
1372 if ( p_sreg->in_use )
1374 p_this_uuid = gatts_get_service_uuid (p_sreg->p_db);
1377 gatt_uuid_compare (*p_app_uuid128, p_sreg->app_uuid ) &&
1378 gatt_uuid_compare (*p_svc_uuid, *p_this_uuid) &&
1379 (svc_inst == p_sreg->service_instance))
1381 GATT_TRACE_ERROR ("Active Service Found ");
1382 gatt_dbg_display_uuid(*p_svc_uuid);
1390 /*******************************************************************************
1392 ** Function gatt_sr_find_i_rcb_by_handle
1394 ** Description The function searches for a service that owns a specific handle.
1396 ** Returns 0 if not found. Otherwise index of th eservice.
1398 *******************************************************************************/
1399 UINT8 gatt_sr_alloc_rcb(tGATT_HDL_LIST_ELEM *p_list )
1402 tGATT_SR_REG *p_sreg = NULL;
1404 /*this is a new application servoce start */
1405 for (ii = 0, p_sreg = gatt_cb.sr_reg; ii < GATT_MAX_SR_PROFILES; ii++, p_sreg++)
1407 if (!p_sreg->in_use)
1409 memset (p_sreg, 0, sizeof(tGATT_SR_REG));
1411 p_sreg->in_use = TRUE;
1412 memcpy (&p_sreg->app_uuid, &p_list->asgn_range.app_uuid128, sizeof(tBT_UUID));
1414 p_sreg->service_instance = p_list->asgn_range.svc_inst;
1415 p_sreg->type = p_list->asgn_range.is_primary ? GATT_UUID_PRI_SERVICE: GATT_UUID_SEC_SERVICE;
1416 p_sreg->s_hdl = p_list->asgn_range.s_handle;
1417 p_sreg->e_hdl = p_list->asgn_range.e_handle;
1418 p_sreg->p_db = &p_list->svc_db;
1420 GATT_TRACE_DEBUG("total buffer in db [%d]",
1421 fixed_queue_length(p_sreg->p_db->svc_buffer));
1428 /*******************************************************************************
1430 ** Function gatt_sr_get_sec_info
1432 ** Description Get the security flag and key size information for the peer
1437 *******************************************************************************/
1438 void gatt_sr_get_sec_info(BD_ADDR rem_bda, tBT_TRANSPORT transport, UINT8 *p_sec_flag, UINT8 *p_key_size)
1442 BTM_GetSecurityFlagsByTransport(rem_bda, &sec_flag, transport);
1444 sec_flag &= (GATT_SEC_FLAG_LKEY_UNAUTHED | GATT_SEC_FLAG_LKEY_AUTHED | GATT_SEC_FLAG_ENCRYPTED);
1446 *p_key_size = btm_ble_read_sec_key_size(rem_bda);
1447 *p_sec_flag = sec_flag;
1449 /*******************************************************************************
1451 ** Function gatt_sr_send_req_callback
1458 *******************************************************************************/
1459 void gatt_sr_send_req_callback(UINT16 conn_id,
1461 tGATTS_REQ_TYPE type, tGATTS_DATA *p_data)
1463 tGATT_IF gatt_if = GATT_GET_GATT_IF(conn_id);
1464 tGATT_REG *p_reg = gatt_get_regcb(gatt_if);
1468 GATT_TRACE_ERROR ("p_reg not found discard request");
1472 if ( p_reg->in_use &&
1473 p_reg->app_cb.p_req_cb)
1475 (*p_reg->app_cb.p_req_cb)(conn_id, trans_id, type, p_data);
1479 GATT_TRACE_WARNING("Call back not found for application conn_id=%d", conn_id);
1484 /*******************************************************************************
1486 ** Function gatt_send_error_rsp
1488 ** Description This function sends an error response.
1492 *******************************************************************************/
1493 tGATT_STATUS gatt_send_error_rsp (tGATT_TCB *p_tcb, UINT8 err_code, UINT8 op_code,
1494 UINT16 handle, BOOLEAN deq)
1497 tGATT_STATUS status;
1500 error.cmd_code = op_code;
1501 error.reason = err_code;
1502 error.handle =handle;
1504 if ((p_buf = attp_build_sr_msg(p_tcb, GATT_RSP_ERROR, (tGATT_SR_MSG *)&error)) != NULL)
1506 status = attp_send_sr_msg (p_tcb, p_buf);
1509 status = GATT_INSUF_RESOURCE;
1512 gatt_dequeue_sr_cmd(p_tcb);
1518 /*******************************************************************************
1520 ** Function gatt_add_sdp_record
1522 ** Description This function add a SDP record for a GATT primary service
1524 ** Returns 0 if error else sdp handle for the record.
1526 *******************************************************************************/
1527 UINT32 gatt_add_sdp_record (tBT_UUID *p_uuid, UINT16 start_hdl, UINT16 end_hdl)
1529 tSDP_PROTOCOL_ELEM proto_elem_list[2];
1531 UINT16 list = UUID_SERVCLASS_PUBLIC_BROWSE_GROUP;
1535 GATT_TRACE_DEBUG("gatt_add_sdp_record s_hdl=0x%x s_hdl=0x%x",start_hdl, end_hdl);
1537 if ((sdp_handle = SDP_CreateRecord()) == 0)
1540 switch (p_uuid->len)
1543 SDP_AddServiceClassIdList(sdp_handle, 1, &p_uuid->uu.uuid16);
1547 UINT8_TO_BE_STREAM (p, (UUID_DESC_TYPE << 3) | SIZE_FOUR_BYTES);
1548 UINT32_TO_BE_STREAM (p, p_uuid->uu.uuid32);
1549 SDP_AddAttribute (sdp_handle, ATTR_ID_SERVICE_CLASS_ID_LIST, DATA_ELE_SEQ_DESC_TYPE,
1550 (UINT32) (p - buff), buff);
1554 UINT8_TO_BE_STREAM (p, (UUID_DESC_TYPE << 3) | SIZE_SIXTEEN_BYTES);
1555 ARRAY_TO_BE_STREAM_REVERSE (p, p_uuid->uu.uuid128, LEN_UUID_128);
1556 SDP_AddAttribute (sdp_handle, ATTR_ID_SERVICE_CLASS_ID_LIST, DATA_ELE_SEQ_DESC_TYPE,
1557 (UINT32) (p - buff), buff);
1561 GATT_TRACE_ERROR("inavlid UUID len=%d", p_uuid->len);
1562 SDP_DeleteRecord(sdp_handle);
1567 /*** Fill out the protocol element sequence for SDP ***/
1568 proto_elem_list[0].protocol_uuid = UUID_PROTOCOL_L2CAP;
1569 proto_elem_list[0].num_params = 1;
1570 proto_elem_list[0].params[0] = BT_PSM_ATT;
1571 proto_elem_list[1].protocol_uuid = UUID_PROTOCOL_ATT;
1572 proto_elem_list[1].num_params = 2;
1573 proto_elem_list[1].params[0] = start_hdl;
1574 proto_elem_list[1].params[1] = end_hdl;
1576 SDP_AddProtocolList(sdp_handle, 2, proto_elem_list);
1578 /* Make the service browseable */
1579 SDP_AddUuidSequence (sdp_handle, ATTR_ID_BROWSE_GROUP_LIST, 1, &list);
1585 #if GATT_CONFORMANCE_TESTING == TRUE
1586 /*******************************************************************************
1588 ** Function gatt_set_err_rsp
1590 ** Description This function is called to set the test confirm value
1594 *******************************************************************************/
1595 void gatt_set_err_rsp(BOOLEAN enable, UINT8 req_op_code, UINT8 err_status)
1597 GATT_TRACE_DEBUG("gatt_set_err_rsp enable=%d op_code=%d, err_status=%d", enable, req_op_code, err_status);
1598 gatt_cb.enable_err_rsp = enable;
1599 gatt_cb.req_op_code = req_op_code;
1600 gatt_cb.err_status = err_status;
1606 /*******************************************************************************
1608 ** Function gatt_get_regcb
1610 ** Description The function returns the registration control block.
1612 ** Returns pointer to the registration control block or NULL
1614 *******************************************************************************/
1615 tGATT_REG *gatt_get_regcb (tGATT_IF gatt_if)
1617 UINT8 ii = (UINT8)gatt_if;
1618 tGATT_REG *p_reg = NULL;
1620 if (ii < 1 || ii > GATT_MAX_APPS) {
1621 GATT_TRACE_WARNING("gatt_if out of range [ = %d]", ii);
1625 // Index for cl_rcb is always 1 less than gatt_if.
1626 p_reg = &gatt_cb.cl_rcb[ii - 1];
1628 if (!p_reg->in_use) {
1629 GATT_TRACE_WARNING("gatt_if found but not in use.");
1637 /*******************************************************************************
1639 ** Function gatt_is_clcb_allocated
1641 ** Description The function check clcb for conn_id is allocated or not
1643 ** Returns True already allocated
1645 *******************************************************************************/
1647 BOOLEAN gatt_is_clcb_allocated (UINT16 conn_id)
1650 BOOLEAN is_allocated= FALSE;
1652 for (i = 0; i < GATT_CL_MAX_LCB; i++)
1654 if (gatt_cb.clcb[i].in_use && (gatt_cb.clcb[i].conn_id == conn_id))
1656 is_allocated = TRUE;
1661 return is_allocated;
1664 /*******************************************************************************
1666 ** Function gatt_clcb_alloc
1668 ** Description The function allocates a GATT connection link control block
1670 ** Returns NULL if not found. Otherwise pointer to the connection link block.
1672 *******************************************************************************/
1673 tGATT_CLCB *gatt_clcb_alloc (UINT16 conn_id)
1676 tGATT_CLCB *p_clcb = NULL;
1677 tGATT_IF gatt_if=GATT_GET_GATT_IF(conn_id);
1678 UINT8 tcb_idx = GATT_GET_TCB_IDX(conn_id);
1679 tGATT_TCB *p_tcb = gatt_get_tcb_by_idx(tcb_idx);
1680 tGATT_REG *p_reg = gatt_get_regcb(gatt_if);
1682 for (i = 0; i < GATT_CL_MAX_LCB; i++)
1684 if (!gatt_cb.clcb[i].in_use)
1686 p_clcb = &gatt_cb.clcb[i];
1688 p_clcb->in_use = TRUE;
1689 p_clcb->conn_id = conn_id;
1690 p_clcb->clcb_idx = i;
1691 p_clcb->p_reg = p_reg;
1692 p_clcb->p_tcb = p_tcb;
1699 /*******************************************************************************
1701 ** Function gatt_clcb_dealloc
1703 ** Description The function de allocates a GATT connection link control block
1707 *******************************************************************************/
1708 void gatt_clcb_dealloc (tGATT_CLCB *p_clcb)
1710 if (p_clcb && p_clcb->in_use)
1712 alarm_free(p_clcb->gatt_rsp_timer_ent);
1713 memset(p_clcb, 0, sizeof(tGATT_CLCB));
1719 /*******************************************************************************
1721 ** Function gatt_find_tcb_by_cid
1723 ** Description The function searches for an empty entry
1724 ** in registration info table for GATT client
1726 ** Returns NULL if not found. Otherwise pointer to the rcb.
1728 *******************************************************************************/
1729 tGATT_TCB * gatt_find_tcb_by_cid (UINT16 lcid)
1732 tGATT_TCB *p_tcb = NULL;
1734 for (xx = 0; xx < GATT_MAX_PHY_CHANNEL; xx++)
1736 if (gatt_cb.tcb[xx].in_use && gatt_cb.tcb[xx].att_lcid == lcid)
1738 p_tcb = &gatt_cb.tcb[xx];
1746 /*******************************************************************************
1748 ** Function gatt_num_apps_hold_link
1750 ** Description The function find the number of applcaitions is holding the link
1752 ** Returns total number of applications holding this acl link.
1754 *******************************************************************************/
1755 UINT8 gatt_num_apps_hold_link(tGATT_TCB *p_tcb)
1759 for (i = 0; i < GATT_MAX_APPS; i ++)
1761 if (p_tcb->app_hold_link[i])
1765 GATT_TRACE_DEBUG("gatt_num_apps_hold_link num=%d", num);
1770 /*******************************************************************************
1772 ** Function gatt_num_clcb_by_bd_addr
1774 ** Description The function searches all LCB with macthing bd address
1776 ** Returns total number of clcb found.
1778 *******************************************************************************/
1779 UINT8 gatt_num_clcb_by_bd_addr(BD_ADDR bda)
1783 for (i = 0; i < GATT_CL_MAX_LCB; i ++)
1785 if (gatt_cb.clcb[i].in_use && memcmp(gatt_cb.clcb[i].p_tcb->peer_bda, bda, BD_ADDR_LEN) == 0)
1791 /*******************************************************************************
1793 ** Function gatt_sr_update_cback_cnt
1795 ** Description The function searches all LCB with macthing bd address
1797 ** Returns total number of clcb found.
1799 *******************************************************************************/
1800 void gatt_sr_copy_prep_cnt_to_cback_cnt(tGATT_TCB *p_tcb )
1806 for (i = 0; i < GATT_MAX_APPS; i ++)
1808 if (p_tcb->prep_cnt[i])
1810 p_tcb->sr_cmd.cback_cnt[i]=1;
1817 /*******************************************************************************
1819 ** Function gatt_sr_is_cback_cnt_zero
1821 ** Description The function searches all LCB with macthing bd address
1823 ** Returns True if thetotal application callback count is zero
1825 *******************************************************************************/
1826 BOOLEAN gatt_sr_is_cback_cnt_zero(tGATT_TCB *p_tcb )
1828 BOOLEAN status = TRUE;
1833 for (i = 0; i < GATT_MAX_APPS; i ++)
1835 if (p_tcb->sr_cmd.cback_cnt[i])
1849 /*******************************************************************************
1851 ** Function gatt_sr_is_prep_cnt_zero
1853 ** Description Check the prepare write request count is zero or not
1855 ** Returns True no prepare write request
1857 *******************************************************************************/
1858 BOOLEAN gatt_sr_is_prep_cnt_zero(tGATT_TCB *p_tcb)
1860 BOOLEAN status = TRUE;
1865 for (i = 0; i < GATT_MAX_APPS; i ++)
1867 if (p_tcb->prep_cnt[i])
1882 /*******************************************************************************
1884 ** Function gatt_sr_reset_cback_cnt
1886 ** Description Reset the application callback count to zero
1890 *******************************************************************************/
1891 void gatt_sr_reset_cback_cnt(tGATT_TCB *p_tcb )
1897 for (i = 0; i < GATT_MAX_APPS; i ++)
1899 p_tcb->sr_cmd.cback_cnt[i]=0;
1904 /*******************************************************************************
1906 ** Function gatt_sr_reset_prep_cnt
1908 ** Description Reset the prep write count to zero
1912 *******************************************************************************/
1913 void gatt_sr_reset_prep_cnt(tGATT_TCB *p_tcb )
1918 for (i = 0; i < GATT_MAX_APPS; i ++)
1920 p_tcb->prep_cnt[i]=0;
1926 /*******************************************************************************
1928 ** Function gatt_sr_update_cback_cnt
1930 ** Description Update the teh applicaiton callback count
1934 *******************************************************************************/
1935 void gatt_sr_update_cback_cnt(tGATT_TCB *p_tcb, tGATT_IF gatt_if, BOOLEAN is_inc, BOOLEAN is_reset_first)
1938 UINT8 idx = ((UINT8) gatt_if) - 1 ;
1944 gatt_sr_reset_cback_cnt(p_tcb);
1948 p_tcb->sr_cmd.cback_cnt[idx]++;
1952 if ( p_tcb->sr_cmd.cback_cnt[idx])
1954 p_tcb->sr_cmd.cback_cnt[idx]--;
1961 /*******************************************************************************
1963 ** Function gatt_sr_update_prep_cnt
1965 ** Description Update the teh prepare write request count
1969 *******************************************************************************/
1970 void gatt_sr_update_prep_cnt(tGATT_TCB *p_tcb, tGATT_IF gatt_if, BOOLEAN is_inc, BOOLEAN is_reset_first)
1972 UINT8 idx = ((UINT8) gatt_if) - 1 ;
1974 GATT_TRACE_DEBUG("gatt_sr_update_prep_cnt tcb idx=%d gatt_if=%d is_inc=%d is_reset_first=%d",
1975 p_tcb->tcb_idx, gatt_if, is_inc, is_reset_first);
1981 gatt_sr_reset_prep_cnt(p_tcb);
1985 p_tcb->prep_cnt[idx]++;
1989 if (p_tcb->prep_cnt[idx])
1991 p_tcb->prep_cnt[idx]--;
1996 /*******************************************************************************
1998 ** Function gatt_cancel_open
2000 ** Description Cancel open request
2004 *******************************************************************************/
2005 BOOLEAN gatt_cancel_open(tGATT_IF gatt_if, BD_ADDR bda)
2007 tGATT_TCB *p_tcb=NULL;
2008 BOOLEAN status= TRUE;
2010 p_tcb = gatt_find_tcb_by_addr(bda, BT_TRANSPORT_LE);
2014 if (gatt_get_ch_state(p_tcb) == GATT_CH_OPEN)
2016 GATT_TRACE_ERROR("GATT_CancelConnect - link connected Too late to cancel");
2021 gatt_update_app_use_link_flag(gatt_if, p_tcb, FALSE, FALSE);
2022 if (!gatt_num_apps_hold_link(p_tcb))
2024 gatt_disconnect(p_tcb);
2032 /*******************************************************************************
2034 ** Function gatt_find_app_hold_link
2036 ** Description find the applicaiton that is holding the specified link
2040 *******************************************************************************/
2041 BOOLEAN gatt_find_app_hold_link(tGATT_TCB *p_tcb, UINT8 start_idx, UINT8 *p_found_idx, tGATT_IF *p_gatt_if)
2044 BOOLEAN found= FALSE;
2046 for (i = start_idx; i < GATT_MAX_APPS; i ++)
2048 if (p_tcb->app_hold_link[i])
2050 *p_gatt_if = gatt_cb.clcb[i].p_reg->gatt_if;
2059 /*******************************************************************************
2061 ** Function gatt_cmd_enq
2063 ** Description Enqueue this command.
2067 *******************************************************************************/
2068 BOOLEAN gatt_cmd_enq(tGATT_TCB *p_tcb, UINT16 clcb_idx, BOOLEAN to_send, UINT8 op_code, BT_HDR *p_buf)
2070 tGATT_CMD_Q *p_cmd = &p_tcb->cl_cmd_q[p_tcb->next_slot_inq];
2072 p_cmd->to_send = to_send; /* waiting to be sent */
2073 p_cmd->op_code = op_code;
2074 p_cmd->p_cmd = p_buf;
2075 p_cmd->clcb_idx = clcb_idx;
2079 p_tcb->pending_cl_req = p_tcb->next_slot_inq;
2082 p_tcb->next_slot_inq ++;
2083 p_tcb->next_slot_inq %= GATT_CL_MAX_LCB;
2088 /*******************************************************************************
2090 ** Function gatt_cmd_dequeue
2092 ** Description dequeue the command in the client CCB command queue.
2094 ** Returns total number of clcb found.
2096 *******************************************************************************/
2097 tGATT_CLCB * gatt_cmd_dequeue(tGATT_TCB *p_tcb, UINT8 *p_op_code)
2099 tGATT_CMD_Q *p_cmd = &p_tcb->cl_cmd_q[p_tcb->pending_cl_req];
2100 tGATT_CLCB *p_clcb = NULL;
2102 if (p_tcb->pending_cl_req != p_tcb->next_slot_inq)
2104 p_clcb = &gatt_cb.clcb[p_cmd->clcb_idx];
2106 *p_op_code = p_cmd->op_code;
2108 p_tcb->pending_cl_req ++;
2109 p_tcb->pending_cl_req %= GATT_CL_MAX_LCB;
2115 /*******************************************************************************
2117 ** Function gatt_send_write_msg
2119 ** Description This real function send out the ATT message for write.
2121 ** Returns status code
2123 *******************************************************************************/
2124 UINT8 gatt_send_write_msg (tGATT_TCB *p_tcb, UINT16 clcb_idx, UINT8 op_code,
2125 UINT16 handle, UINT16 len,
2126 UINT16 offset, UINT8 *p_data)
2130 msg.attr_value.handle = handle;
2131 msg.attr_value.len = len;
2132 msg.attr_value.offset = offset;
2134 memcpy (msg.attr_value.value, p_data, len);
2136 /* write by handle */
2137 return attp_send_cl_msg(p_tcb, clcb_idx, op_code, &msg);
2140 /*******************************************************************************
2142 ** Function gatt_act_send_browse
2144 ** Description This function ends a browse command request, including read
2145 ** information request and read by type request.
2147 ** Returns status code
2149 *******************************************************************************/
2150 UINT8 gatt_act_send_browse(tGATT_TCB *p_tcb, UINT16 index, UINT8 op, UINT16 s_handle,
2151 UINT16 e_handle, tBT_UUID uuid)
2155 msg.browse.s_handle = s_handle;
2156 msg.browse.e_handle = e_handle;
2157 memcpy(&msg.browse.uuid, &uuid, sizeof(tBT_UUID));
2159 /* write by handle */
2160 return attp_send_cl_msg(p_tcb, index, op, &msg);
2163 /*******************************************************************************
2165 ** Function gatt_end_operation
2167 ** Description This function ends a discovery, send callback and finalize
2168 ** some control value.
2170 ** Returns 16 bits uuid.
2172 *******************************************************************************/
2173 void gatt_end_operation(tGATT_CLCB *p_clcb, tGATT_STATUS status, void *p_data)
2175 tGATT_CL_COMPLETE cb_data;
2176 tGATT_CMPL_CBACK *p_cmpl_cb = (p_clcb->p_reg) ? p_clcb->p_reg->app_cb.p_cmpl_cb : NULL;
2177 UINT8 op = p_clcb->operation, disc_type=GATT_DISC_MAX;
2178 tGATT_DISC_CMPL_CB *p_disc_cmpl_cb = (p_clcb->p_reg) ? p_clcb->p_reg->app_cb.p_disc_cmpl_cb : NULL;
2182 GATT_TRACE_DEBUG ("gatt_end_operation status=%d op=%d subtype=%d",
2183 status, p_clcb->operation, p_clcb->op_subtype);
2184 memset(&cb_data.att_value, 0, sizeof(tGATT_VALUE));
2186 if (p_cmpl_cb != NULL && p_clcb->operation != 0)
2188 if (p_clcb->operation == GATTC_OPTYPE_READ)
2190 cb_data.att_value.handle = p_clcb->s_handle;
2191 cb_data.att_value.len = p_clcb->counter;
2193 if (p_data && p_clcb->counter)
2194 memcpy (cb_data.att_value.value, p_data, cb_data.att_value.len);
2197 if (p_clcb->operation == GATTC_OPTYPE_WRITE)
2199 memset(&cb_data.att_value, 0, sizeof(tGATT_VALUE));
2201 cb_data.att_value.handle = p_clcb->s_handle;
2202 if (p_clcb->op_subtype == GATT_WRITE_PREPARE)
2206 cb_data.att_value = *((tGATT_VALUE *) p_data);
2210 GATT_TRACE_DEBUG("Rcv Prepare write rsp but no data");
2215 if (p_clcb->operation == GATTC_OPTYPE_CONFIG)
2216 cb_data.mtu = p_clcb->p_tcb->payload_size;
2218 if (p_clcb->operation == GATTC_OPTYPE_DISCOVERY)
2220 disc_type = p_clcb->op_subtype;
2224 osi_free_and_reset((void **)&p_clcb->p_attr_buf);
2226 operation = p_clcb->operation;
2227 conn_id = p_clcb->conn_id;
2228 alarm_cancel(p_clcb->gatt_rsp_timer_ent);
2230 gatt_clcb_dealloc(p_clcb);
2232 if (p_disc_cmpl_cb && (op == GATTC_OPTYPE_DISCOVERY))
2233 (*p_disc_cmpl_cb)(conn_id, disc_type, status);
2234 else if (p_cmpl_cb && op)
2235 (*p_cmpl_cb)(conn_id, op, status, &cb_data);
2237 GATT_TRACE_WARNING ("gatt_end_operation not sent out op=%d p_disc_cmpl_cb:%p p_cmpl_cb:%p",
2238 operation, p_disc_cmpl_cb, p_cmpl_cb);
2241 /*******************************************************************************
2243 ** Function gatt_cleanup_upon_disc
2245 ** Description This function cleans up the control blocks when L2CAP channel
2248 ** Returns 16 bits uuid.
2250 *******************************************************************************/
2251 void gatt_cleanup_upon_disc(BD_ADDR bda, UINT16 reason, tBT_TRANSPORT transport)
2253 tGATT_TCB *p_tcb = NULL;
2257 tGATT_REG *p_reg=NULL;
2260 GATT_TRACE_DEBUG ("gatt_cleanup_upon_disc ");
2262 if ((p_tcb = gatt_find_tcb_by_addr(bda, transport)) != NULL)
2264 GATT_TRACE_DEBUG ("found p_tcb ");
2265 gatt_set_ch_state(p_tcb, GATT_CH_CLOSE);
2266 for (i = 0; i < GATT_CL_MAX_LCB; i ++)
2268 p_clcb = &gatt_cb.clcb[i];
2269 if (p_clcb->in_use && p_clcb->p_tcb == p_tcb)
2271 alarm_cancel(p_clcb->gatt_rsp_timer_ent);
2272 GATT_TRACE_DEBUG ("found p_clcb conn_id=%d clcb_idx=%d", p_clcb->conn_id, p_clcb->clcb_idx);
2273 if (p_clcb->operation != GATTC_OPTYPE_NONE)
2274 gatt_end_operation(p_clcb, GATT_ERROR, NULL);
2276 gatt_clcb_dealloc(p_clcb);
2281 alarm_free(p_tcb->ind_ack_timer);
2282 p_tcb->ind_ack_timer = NULL;
2283 alarm_free(p_tcb->conf_timer);
2284 p_tcb->conf_timer = NULL;
2285 gatt_free_pending_ind(p_tcb);
2286 gatt_free_pending_enc_queue(p_tcb);
2287 fixed_queue_free(p_tcb->sr_cmd.multi_rsp_q, NULL);
2289 for (i = 0; i < GATT_MAX_APPS; i ++)
2291 p_reg = &gatt_cb.cl_rcb[i];
2292 if (p_reg->in_use && p_reg->app_cb.p_conn_cb)
2294 conn_id = GATT_CREATE_CONN_ID(p_tcb->tcb_idx, p_reg->gatt_if);
2295 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);
2296 (*p_reg->app_cb.p_conn_cb)(p_reg->gatt_if, bda, conn_id, FALSE, reason, transport);
2299 memset(p_tcb, 0, sizeof(tGATT_TCB));
2302 GATT_TRACE_DEBUG ("exit gatt_cleanup_upon_disc ");
2304 /*******************************************************************************
2306 ** Function gatt_dbg_req_op_name
2308 ** Description Get op code description name, for debug information.
2310 ** Returns UINT8 *: name of the operation.
2312 *******************************************************************************/
2313 UINT8 * gatt_dbg_op_name(UINT8 op_code)
2315 UINT8 pseduo_op_code_idx = op_code & (~GATT_WRITE_CMD_MASK);
2317 if (op_code == GATT_CMD_WRITE )
2319 pseduo_op_code_idx = 0x14; /* just an index to op_code_name */
2323 if (op_code == GATT_SIGN_CMD_WRITE)
2325 pseduo_op_code_idx = 0x15; /* just an index to op_code_name */
2328 if (pseduo_op_code_idx <= GATT_OP_CODE_MAX)
2329 return(UINT8*) op_code_name[pseduo_op_code_idx];
2331 return(UINT8 *)"Op Code Exceed Max";
2334 /*******************************************************************************
2336 ** Function gatt_dbg_display_uuid
2338 ** Description Disaplay the UUID
2342 *******************************************************************************/
2343 void gatt_dbg_display_uuid(tBT_UUID bt_uuid)
2348 if (bt_uuid.len == LEN_UUID_16)
2350 sprintf(str_buf, "0x%04x", bt_uuid.uu.uuid16);
2352 else if (bt_uuid.len == LEN_UUID_32)
2354 sprintf(str_buf, "0x%08x", (unsigned int)bt_uuid.uu.uuid32);
2356 else if (bt_uuid.len == LEN_UUID_128)
2358 x += sprintf(&str_buf[x], "0x%02x%02x%02x%02x%02x%02x%02x%02x",
2359 bt_uuid.uu.uuid128[15], bt_uuid.uu.uuid128[14],
2360 bt_uuid.uu.uuid128[13], bt_uuid.uu.uuid128[12],
2361 bt_uuid.uu.uuid128[11], bt_uuid.uu.uuid128[10],
2362 bt_uuid.uu.uuid128[9], bt_uuid.uu.uuid128[8]);
2363 sprintf(&str_buf[x], "%02x%02x%02x%02x%02x%02x%02x%02x",
2364 bt_uuid.uu.uuid128[7], bt_uuid.uu.uuid128[6],
2365 bt_uuid.uu.uuid128[5], bt_uuid.uu.uuid128[4],
2366 bt_uuid.uu.uuid128[3], bt_uuid.uu.uuid128[2],
2367 bt_uuid.uu.uuid128[1], bt_uuid.uu.uuid128[0]);
2370 strlcpy(str_buf, "Unknown UUID 0", sizeof(str_buf));
2372 GATT_TRACE_DEBUG ("UUID=[%s]", str_buf);
2376 /*******************************************************************************
2378 ** Function gatt_is_bg_dev_for_app
2380 ** Description find is this one of the background devices for the application
2382 ** Returns TRUE this is one of the background devices for the application
2384 *******************************************************************************/
2385 BOOLEAN gatt_is_bg_dev_for_app(tGATT_BG_CONN_DEV *p_dev, tGATT_IF gatt_if)
2389 for (i = 0; i < GATT_MAX_APPS; i ++ )
2391 if (p_dev->in_use && (p_dev->gatt_if[i] == gatt_if))
2398 /*******************************************************************************
2400 ** Function gatt_find_bg_dev
2402 ** Description find background connection device from the list.
2404 ** Returns pointer to the device record
2406 *******************************************************************************/
2407 tGATT_BG_CONN_DEV * gatt_find_bg_dev(BD_ADDR remote_bda)
2409 tGATT_BG_CONN_DEV *p_dev_list = &gatt_cb.bgconn_dev[0];
2412 for (i = 0; i < GATT_MAX_BG_CONN_DEV; i ++, p_dev_list ++)
2414 if (p_dev_list->in_use && !memcmp(p_dev_list->remote_bda, remote_bda, BD_ADDR_LEN))
2421 /*******************************************************************************
2423 ** Function gatt_alloc_bg_dev
2425 ** Description allocate a background connection device record
2427 ** Returns pointer to the device record
2429 *******************************************************************************/
2430 tGATT_BG_CONN_DEV * gatt_alloc_bg_dev(BD_ADDR remote_bda)
2432 tGATT_BG_CONN_DEV *p_dev_list = &gatt_cb.bgconn_dev[0];
2435 for (i = 0; i < GATT_MAX_BG_CONN_DEV; i ++, p_dev_list ++)
2437 if (!p_dev_list->in_use)
2439 p_dev_list->in_use = TRUE;
2440 memcpy(p_dev_list->remote_bda, remote_bda, BD_ADDR_LEN);
2448 /*******************************************************************************
2450 ** Function gatt_add_bg_dev_list
2452 ** Description add/remove device from the back ground connection device list
2454 ** Returns TRUE if device added to the list; FALSE failed
2456 *******************************************************************************/
2457 BOOLEAN gatt_add_bg_dev_list(tGATT_REG *p_reg, BD_ADDR bd_addr, BOOLEAN is_initator)
2459 tGATT_IF gatt_if = p_reg->gatt_if;
2460 tGATT_BG_CONN_DEV *p_dev = NULL;
2462 BOOLEAN ret = FALSE;
2464 if ((p_dev = gatt_find_bg_dev(bd_addr)) == NULL)
2466 p_dev = gatt_alloc_bg_dev(bd_addr);
2471 for (i = 0; i < GATT_MAX_APPS; i ++)
2475 if (p_dev->gatt_if[i] == gatt_if)
2477 GATT_TRACE_ERROR("device already in iniator white list");
2480 else if (p_dev->gatt_if[i] == 0)
2482 p_dev->gatt_if[i] = gatt_if;
2484 ret = BTM_BleUpdateBgConnDev(TRUE, bd_addr);
2492 if (p_dev->listen_gif[i] == gatt_if)
2494 GATT_TRACE_ERROR("device already in adv white list");
2497 else if (p_dev->listen_gif[i] == 0)
2499 if (p_reg->listening == GATT_LISTEN_TO_ALL)
2500 p_reg->listening = GATT_LISTEN_TO_NONE;
2502 p_reg->listening ++;
2503 p_dev->listen_gif[i] = gatt_if;
2506 ret = BTM_BleUpdateAdvWhitelist(TRUE, bd_addr);
2516 GATT_TRACE_ERROR("no device record available");
2522 /*******************************************************************************
2524 ** Function gatt_remove_bg_dev_for_app
2526 ** Description Remove the application interface for the specified background device
2530 *******************************************************************************/
2531 BOOLEAN gatt_remove_bg_dev_for_app(tGATT_IF gatt_if, BD_ADDR bd_addr)
2533 tGATT_TCB *p_tcb = gatt_find_tcb_by_addr(bd_addr, BT_TRANSPORT_LE);
2537 gatt_update_app_use_link_flag(gatt_if, p_tcb, FALSE, FALSE);
2538 status = gatt_update_auto_connect_dev(gatt_if, FALSE, bd_addr, TRUE);
2543 /*******************************************************************************
2545 ** Function gatt_get_num_apps_for_bg_dev
2547 ** Description Gte the number of applciations for the specified background device
2549 ** Returns UINT8 total number fo applications
2551 *******************************************************************************/
2552 UINT8 gatt_get_num_apps_for_bg_dev(BD_ADDR bd_addr)
2554 tGATT_BG_CONN_DEV *p_dev = NULL;
2558 if ((p_dev = gatt_find_bg_dev(bd_addr)) != NULL)
2560 for (i = 0; i < GATT_MAX_APPS; i ++)
2562 if (p_dev->gatt_if[i])
2569 /*******************************************************************************
2571 ** Function gatt_find_app_for_bg_dev
2573 ** Description find the application interface for the specified background device
2577 *******************************************************************************/
2578 BOOLEAN gatt_find_app_for_bg_dev(BD_ADDR bd_addr, tGATT_IF *p_gatt_if)
2580 tGATT_BG_CONN_DEV *p_dev = NULL;
2582 BOOLEAN ret = FALSE;
2584 if ((p_dev = gatt_find_bg_dev(bd_addr)) == NULL)
2589 for (i = 0; i < GATT_MAX_APPS; i ++)
2591 if (p_dev->gatt_if[i] != 0 )
2593 *p_gatt_if = p_dev->gatt_if[i];
2602 /*******************************************************************************
2604 ** Function gatt_remove_bg_dev_from_list
2606 ** Description add/remove device from the back ground connection device list or
2607 ** listening to advertising list.
2609 ** Returns pointer to the device record
2611 *******************************************************************************/
2612 BOOLEAN gatt_remove_bg_dev_from_list(tGATT_REG *p_reg, BD_ADDR bd_addr, BOOLEAN is_initiator)
2614 tGATT_IF gatt_if = p_reg->gatt_if;
2615 tGATT_BG_CONN_DEV *p_dev = NULL;
2617 BOOLEAN ret = FALSE;
2619 if ((p_dev = gatt_find_bg_dev(bd_addr)) == NULL)
2624 for (i = 0; i < GATT_MAX_APPS && (p_dev->gatt_if[i] > 0 || p_dev->listen_gif[i]); i ++)
2628 if (p_dev->gatt_if[i] == gatt_if)
2630 p_dev->gatt_if[i] = 0;
2631 /* move all element behind one forward */
2632 for (j = i + 1; j < GATT_MAX_APPS; j ++)
2633 p_dev->gatt_if[j - 1] = p_dev->gatt_if[j];
2635 if (p_dev->gatt_if[0] == 0)
2636 ret = BTM_BleUpdateBgConnDev(FALSE, p_dev->remote_bda);
2645 if (p_dev->listen_gif[i] == gatt_if)
2647 p_dev->listen_gif[i] = 0;
2648 p_reg->listening --;
2649 /* move all element behind one forward */
2650 for (j = i + 1; j < GATT_MAX_APPS; j ++)
2651 p_dev->listen_gif[j - 1] = p_dev->listen_gif[j];
2653 if (p_dev->listen_gif[0] == 0)
2654 ret = BTM_BleUpdateAdvWhitelist(FALSE, p_dev->remote_bda);
2662 if (i != GATT_MAX_APPS && p_dev->gatt_if[0] == 0 && p_dev->listen_gif[0] == 0)
2664 memset(p_dev, 0, sizeof(tGATT_BG_CONN_DEV));
2669 /*******************************************************************************
2671 ** Function gatt_deregister_bgdev_list
2673 ** Description deregister all related back ground connetion device.
2675 ** Returns pointer to the device record
2677 *******************************************************************************/
2678 void gatt_deregister_bgdev_list(tGATT_IF gatt_if)
2680 tGATT_BG_CONN_DEV *p_dev_list = &gatt_cb.bgconn_dev[0];
2682 tGATT_REG *p_reg = gatt_get_regcb(gatt_if);
2684 /* update the BG conn device list */
2685 for (i = 0 ; i <GATT_MAX_BG_CONN_DEV; i ++, p_dev_list ++ )
2687 if (p_dev_list->in_use)
2689 for (j = 0; j < GATT_MAX_APPS; j ++)
2691 if (p_dev_list->gatt_if[j] == 0 && p_dev_list->listen_gif[j] == 0)
2694 if (p_dev_list->gatt_if[j] == gatt_if)
2696 for (k = j + 1; k < GATT_MAX_APPS; k ++)
2697 p_dev_list->gatt_if[k - 1] = p_dev_list->gatt_if[k];
2699 if (p_dev_list->gatt_if[0] == 0)
2700 BTM_BleUpdateBgConnDev(FALSE, p_dev_list->remote_bda);
2703 if (p_dev_list->listen_gif[j] == gatt_if)
2705 p_dev_list->listen_gif[j] = 0;
2707 if (p_reg != NULL && p_reg->listening > 0)
2708 p_reg->listening --;
2710 /* move all element behind one forward */
2711 for (k = j + 1; k < GATT_MAX_APPS; k ++)
2712 p_dev_list->listen_gif[k - 1] = p_dev_list->listen_gif[k];
2714 if (p_dev_list->listen_gif[0] == 0)
2715 BTM_BleUpdateAdvWhitelist(FALSE, p_dev_list->remote_bda);
2723 /*******************************************************************************
2725 ** Function gatt_reset_bgdev_list
2727 ** Description reset bg device list
2729 ** Returns pointer to the device record
2731 *******************************************************************************/
2732 void gatt_reset_bgdev_list(void)
2734 memset(&gatt_cb.bgconn_dev, 0 , sizeof(tGATT_BG_CONN_DEV)*GATT_MAX_BG_CONN_DEV);
2737 /*******************************************************************************
2739 ** Function gatt_update_auto_connect_dev
2741 ** Description This function add or remove a device for background connection
2744 ** Parameters gatt_if: Application ID.
2745 ** add: add peer device
2746 ** bd_addr: peer device address.
2748 ** Returns TRUE if connection started; FALSE if connection start failure.
2750 *******************************************************************************/
2751 BOOLEAN gatt_update_auto_connect_dev (tGATT_IF gatt_if, BOOLEAN add, BD_ADDR bd_addr, BOOLEAN is_initator)
2753 BOOLEAN ret = FALSE;
2755 tGATT_TCB *p_tcb = gatt_find_tcb_by_addr(bd_addr, BT_TRANSPORT_LE);
2757 GATT_TRACE_API ("gatt_update_auto_connect_dev ");
2758 /* Make sure app is registered */
2759 if ((p_reg = gatt_get_regcb(gatt_if)) == NULL)
2761 GATT_TRACE_ERROR("gatt_update_auto_connect_dev - gatt_if is not registered", gatt_if);
2767 ret = gatt_add_bg_dev_list(p_reg, bd_addr, is_initator);
2769 if (ret && p_tcb != NULL)
2771 /* if a connected device, update the link holding number */
2772 gatt_update_app_use_link_flag(gatt_if, p_tcb, TRUE, TRUE);
2777 ret = gatt_remove_bg_dev_from_list(p_reg, bd_addr, is_initator);
2784 /*******************************************************************************
2786 ** Function gatt_add_pending_new_srv_start
2788 ** Description Add a pending new srv start to the new service start queue
2790 ** Returns Pointer to the new service start buffer, NULL no buffer available
2792 *******************************************************************************/
2793 tGATT_PENDING_ENC_CLCB* gatt_add_pending_enc_channel_clcb(tGATT_TCB *p_tcb, tGATT_CLCB *p_clcb)
2795 tGATT_PENDING_ENC_CLCB *p_buf =
2796 (tGATT_PENDING_ENC_CLCB *)osi_malloc(sizeof(tGATT_PENDING_ENC_CLCB));
2798 GATT_TRACE_DEBUG ("%s", __func__);
2799 GATT_TRACE_DEBUG("enqueue a new pending encryption channel clcb");
2801 p_buf->p_clcb = p_clcb;
2802 fixed_queue_enqueue(p_tcb->pending_enc_clcb, p_buf);
2806 /*******************************************************************************
2808 ** Function gatt_update_listen_mode
2810 ** Description update peripheral role listening mode
2812 ** Returns Pointer to the new service start buffer, NULL no buffer available
2814 *******************************************************************************/
2815 BOOLEAN gatt_update_listen_mode(void)
2818 tGATT_REG *p_reg = &gatt_cb.cl_rcb[0];
2819 UINT8 listening = 0;
2820 UINT16 connectability, window, interval;
2823 for (; ii < GATT_MAX_APPS; ii ++, p_reg ++)
2825 if ( p_reg->in_use && p_reg->listening > listening)
2827 listening = p_reg->listening;
2831 if (listening == GATT_LISTEN_TO_ALL ||
2832 listening == GATT_LISTEN_TO_NONE)
2833 BTM_BleUpdateAdvFilterPolicy (AP_SCAN_CONN_ALL);
2835 BTM_BleUpdateAdvFilterPolicy (AP_SCAN_CONN_WL);
2839 connectability = BTM_ReadConnectability (&window, &interval);
2841 if (listening != GATT_LISTEN_TO_NONE)
2843 connectability |= BTM_BLE_CONNECTABLE;
2847 if ((connectability & BTM_BLE_CONNECTABLE) == 0)
2848 connectability &= ~BTM_BLE_CONNECTABLE;
2850 /* turning on the adv now */
2851 btm_ble_set_connectability(connectability);