1 /******************************************************************************
2 *
3 * Copyright (C) 2008-2012 Broadcom Corporation
4 *
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:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
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.
16 *
17 ******************************************************************************/
18
19 /******************************************************************************
20 *
21 * this file contains the main ATT functions
22 *
23 ******************************************************************************/
24
25 #include "bt_target.h"
26
27 #if BLE_INCLUDED == TRUE
28
29 #include "bt_common.h"
30 #include "gatt_int.h"
31 #include "l2c_api.h"
32 #include "btm_int.h"
33 #include "btm_ble_int.h"
34 #include "bt_utils.h"
35
36 /* Configuration flags. */
37 #define GATT_L2C_CFG_IND_DONE (1<<0)
38 #define GATT_L2C_CFG_CFM_DONE (1<<1)
39
40 /* minimum GATT MTU size over BR/EDR link
41 */
42 #define GATT_MIN_BR_MTU_SIZE 48
43
44 /********************************************************************************/
45 /* L O C A L F U N C T I O N P R O T O T Y P E S */
46 /********************************************************************************/
47 static void gatt_le_connect_cback (UINT16 chan, BD_ADDR bd_addr, BOOLEAN connected,
48 UINT16 reason, tBT_TRANSPORT transport);
49 static void gatt_le_data_ind (UINT16 chan, BD_ADDR bd_addr, BT_HDR *p_buf);
50 static void gatt_le_cong_cback(BD_ADDR remote_bda, BOOLEAN congest);
51
52 static void gatt_l2cif_connect_ind_cback (BD_ADDR bd_addr, UINT16 l2cap_cid,
53 UINT16 psm, UINT8 l2cap_id);
54 static void gatt_l2cif_connect_cfm_cback (UINT16 l2cap_cid, UINT16 result);
55 static void gatt_l2cif_config_ind_cback (UINT16 l2cap_cid, tL2CAP_CFG_INFO *p_cfg);
56 static void gatt_l2cif_config_cfm_cback (UINT16 l2cap_cid, tL2CAP_CFG_INFO *p_cfg);
57 static void gatt_l2cif_disconnect_ind_cback (UINT16 l2cap_cid, BOOLEAN ack_needed);
58 static void gatt_l2cif_disconnect_cfm_cback (UINT16 l2cap_cid, UINT16 result);
59 static void gatt_l2cif_data_ind_cback (UINT16 l2cap_cid, BT_HDR *p_msg);
60 static void gatt_send_conn_cback (tGATT_TCB *p_tcb);
61 static void gatt_l2cif_congest_cback (UINT16 cid, BOOLEAN congested);
62
63 static const tL2CAP_APPL_INFO dyn_info =
64 {
65 gatt_l2cif_connect_ind_cback,
66 gatt_l2cif_connect_cfm_cback,
67 NULL,
68 gatt_l2cif_config_ind_cback,
69 gatt_l2cif_config_cfm_cback,
70 gatt_l2cif_disconnect_ind_cback,
71 gatt_l2cif_disconnect_cfm_cback,
72 NULL,
73 gatt_l2cif_data_ind_cback,
74 gatt_l2cif_congest_cback,
75 NULL
76 } ;
77
78 #if GATT_DYNAMIC_MEMORY == FALSE
79 tGATT_CB gatt_cb;
80 #endif
81
82 /*******************************************************************************
83 **
84 ** Function gatt_init
85 **
86 ** Description This function is enable the GATT profile on the device.
87 ** It clears out the control blocks, and registers with L2CAP.
88 **
89 ** Returns void
90 **
91 *******************************************************************************/
gatt_init(void)92 void gatt_init (void)
93 {
94 tL2CAP_FIXED_CHNL_REG fixed_reg;
95
96 GATT_TRACE_DEBUG("gatt_init()");
97
98 memset (&gatt_cb, 0, sizeof(tGATT_CB));
99 memset (&fixed_reg, 0, sizeof(tL2CAP_FIXED_CHNL_REG));
100
101 #if defined(GATT_INITIAL_TRACE_LEVEL)
102 gatt_cb.trace_level = GATT_INITIAL_TRACE_LEVEL;
103 #else
104 gatt_cb.trace_level = BT_TRACE_LEVEL_NONE; /* No traces */
105 #endif
106 gatt_cb.def_mtu_size = GATT_DEF_BLE_MTU_SIZE;
107 gatt_cb.sign_op_queue = fixed_queue_new(SIZE_MAX);
108 gatt_cb.srv_chg_clt_q = fixed_queue_new(SIZE_MAX);
109 gatt_cb.pending_new_srv_start_q = fixed_queue_new(SIZE_MAX);
110 /* First, register fixed L2CAP channel for ATT over BLE */
111 fixed_reg.fixed_chnl_opts.mode = L2CAP_FCR_BASIC_MODE;
112 fixed_reg.fixed_chnl_opts.max_transmit = 0xFF;
113 fixed_reg.fixed_chnl_opts.rtrans_tout = 2000;
114 fixed_reg.fixed_chnl_opts.mon_tout = 12000;
115 fixed_reg.fixed_chnl_opts.mps = 670;
116 fixed_reg.fixed_chnl_opts.tx_win_sz = 1;
117
118 fixed_reg.pL2CA_FixedConn_Cb = gatt_le_connect_cback;
119 fixed_reg.pL2CA_FixedData_Cb = gatt_le_data_ind;
120 fixed_reg.pL2CA_FixedCong_Cb = gatt_le_cong_cback; /* congestion callback */
121 fixed_reg.default_idle_tout = 0xffff; /* 0xffff default idle timeout */
122
123 L2CA_RegisterFixedChannel (L2CAP_ATT_CID, &fixed_reg);
124
125 /* Now, register with L2CAP for ATT PSM over BR/EDR */
126 if (!L2CA_Register (BT_PSM_ATT, (tL2CAP_APPL_INFO *) &dyn_info))
127 {
128 GATT_TRACE_ERROR ("ATT Dynamic Registration failed");
129 }
130
131 BTM_SetSecurityLevel(TRUE, "", BTM_SEC_SERVICE_ATT, BTM_SEC_NONE, BT_PSM_ATT, 0, 0);
132 BTM_SetSecurityLevel(FALSE, "", BTM_SEC_SERVICE_ATT, BTM_SEC_NONE, BT_PSM_ATT, 0, 0);
133
134 gatt_cb.hdl_cfg.gatt_start_hdl = GATT_GATT_START_HANDLE;
135 gatt_cb.hdl_cfg.gap_start_hdl = GATT_GAP_START_HANDLE;
136 gatt_cb.hdl_cfg.app_start_hdl = GATT_APP_START_HANDLE;
137 gatt_profile_db_init();
138
139 }
140
141
142 /*******************************************************************************
143 **
144 ** Function gatt_free
145 **
146 ** Description This function frees resources used by the GATT profile.
147 **
148 ** Returns void
149 **
150 *******************************************************************************/
gatt_free(void)151 void gatt_free(void)
152 {
153 int i;
154 GATT_TRACE_DEBUG("gatt_free()");
155
156 fixed_queue_free(gatt_cb.sign_op_queue, NULL);
157 gatt_cb.sign_op_queue = NULL;
158 fixed_queue_free(gatt_cb.srv_chg_clt_q, NULL);
159 gatt_cb.srv_chg_clt_q = NULL;
160 fixed_queue_free(gatt_cb.pending_new_srv_start_q, NULL);
161 gatt_cb.pending_new_srv_start_q = NULL;
162 for (i = 0; i < GATT_MAX_PHY_CHANNEL; i++)
163 {
164 fixed_queue_free(gatt_cb.tcb[i].pending_enc_clcb, NULL);
165 gatt_cb.tcb[i].pending_enc_clcb = NULL;
166
167 fixed_queue_free(gatt_cb.tcb[i].pending_ind_q, NULL);
168 gatt_cb.tcb[i].pending_ind_q = NULL;
169
170 alarm_free(gatt_cb.tcb[i].conf_timer);
171 gatt_cb.tcb[i].conf_timer = NULL;
172
173 alarm_free(gatt_cb.tcb[i].ind_ack_timer);
174 gatt_cb.tcb[i].ind_ack_timer = NULL;
175
176 fixed_queue_free(gatt_cb.tcb[i].sr_cmd.multi_rsp_q, NULL);
177 gatt_cb.tcb[i].sr_cmd.multi_rsp_q = NULL;
178 }
179 for (i = 0; i < GATT_MAX_SR_PROFILES; i++)
180 {
181 gatt_free_hdl_buffer(&gatt_cb.hdl_list[i]);
182 }
183 }
184
185 /*******************************************************************************
186 **
187 ** Function gatt_connect
188 **
189 ** Description This function is called to initiate a connection to a peer device.
190 **
191 ** Parameter rem_bda: remote device address to connect to.
192 **
193 ** Returns TRUE if connection is started, otherwise return FALSE.
194 **
195 *******************************************************************************/
gatt_connect(BD_ADDR rem_bda,tGATT_TCB * p_tcb,tBT_TRANSPORT transport)196 BOOLEAN gatt_connect (BD_ADDR rem_bda, tGATT_TCB *p_tcb, tBT_TRANSPORT transport)
197 {
198 BOOLEAN gatt_ret = FALSE;
199
200 if (gatt_get_ch_state(p_tcb) != GATT_CH_OPEN)
201 gatt_set_ch_state(p_tcb, GATT_CH_CONN);
202
203 if (transport == BT_TRANSPORT_LE)
204 {
205 p_tcb->att_lcid = L2CAP_ATT_CID;
206 gatt_ret = L2CA_ConnectFixedChnl (L2CAP_ATT_CID, rem_bda);
207 }
208 else
209 {
210 if ((p_tcb->att_lcid = L2CA_ConnectReq(BT_PSM_ATT, rem_bda)) != 0)
211 gatt_ret = TRUE;
212 }
213
214 return gatt_ret;
215 }
216
217 /*******************************************************************************
218 **
219 ** Function gatt_disconnect
220 **
221 ** Description This function is called to disconnect to an ATT device.
222 **
223 ** Parameter p_tcb: pointer to the TCB to disconnect.
224 **
225 ** Returns TRUE: if connection found and to be disconnected; otherwise
226 ** return FALSE.
227 **
228 *******************************************************************************/
gatt_disconnect(tGATT_TCB * p_tcb)229 BOOLEAN gatt_disconnect (tGATT_TCB *p_tcb)
230 {
231 BOOLEAN ret = FALSE;
232 tGATT_CH_STATE ch_state;
233
234 GATT_TRACE_EVENT ("%s", __func__);
235
236 if (p_tcb != NULL)
237 {
238 ret = TRUE;
239 if ( (ch_state = gatt_get_ch_state(p_tcb)) != GATT_CH_CLOSING )
240 {
241 if (p_tcb->att_lcid == L2CAP_ATT_CID)
242 {
243 if (ch_state == GATT_CH_OPEN)
244 {
245 /* only LCB exist between remote device and local */
246 ret = L2CA_RemoveFixedChnl (L2CAP_ATT_CID, p_tcb->peer_bda);
247 }
248 else
249 {
250 gatt_set_ch_state(p_tcb, GATT_CH_CLOSING);
251 ret = L2CA_CancelBleConnectReq (p_tcb->peer_bda);
252 }
253 }
254 else
255 {
256 if ((ch_state == GATT_CH_OPEN) || (ch_state == GATT_CH_CFG))
257 ret = L2CA_DisconnectReq(p_tcb->att_lcid);
258 else
259 GATT_TRACE_DEBUG ("%s gatt_disconnect channel not opened", __func__);
260 }
261 }
262 else
263 {
264 GATT_TRACE_DEBUG ("%s already in closing state", __func__);
265 }
266 }
267
268 return ret;
269 }
270
271 /*******************************************************************************
272 **
273 ** Function gatt_update_app_hold_link_status
274 **
275 ** Description Update the application use link status
276 **
277 ** Returns void.
278 **
279 *******************************************************************************/
gatt_update_app_hold_link_status(tGATT_IF gatt_if,tGATT_TCB * p_tcb,BOOLEAN is_add)280 void gatt_update_app_hold_link_status (tGATT_IF gatt_if, tGATT_TCB *p_tcb, BOOLEAN is_add)
281 {
282 UINT8 i;
283 BOOLEAN found=FALSE;
284
285 if (p_tcb == NULL)
286 {
287 GATT_TRACE_ERROR("gatt_update_app_hold_link_status p_tcb=NULL");
288 return;
289 }
290
291
292 for (i=0; i<GATT_MAX_APPS; i++)
293 {
294 if (p_tcb->app_hold_link[i] == gatt_if)
295 {
296 found = TRUE;
297 if (!is_add)
298 {
299 p_tcb->app_hold_link[i] = 0;
300 break;
301 }
302 }
303 }
304
305 if (!found && is_add)
306 {
307 for (i=0; i<GATT_MAX_APPS; i++)
308 {
309 if (p_tcb->app_hold_link[i] == 0)
310 {
311 p_tcb->app_hold_link[i] = gatt_if;
312 found = TRUE;
313 break;
314 }
315 }
316 }
317
318 GATT_TRACE_DEBUG("gatt_update_app_hold_link_status found=%d[1-found] idx=%d gatt_if=%d is_add=%d", found, i, gatt_if, is_add);
319
320 }
321
322 /*******************************************************************************
323 **
324 ** Function gatt_update_app_use_link_flag
325 **
326 ** Description Update the application use link flag and optional to check the acl link
327 ** if the link is up then set the idle time out accordingly
328 **
329 ** Returns void.
330 **
331 *******************************************************************************/
gatt_update_app_use_link_flag(tGATT_IF gatt_if,tGATT_TCB * p_tcb,BOOLEAN is_add,BOOLEAN check_acl_link)332 void gatt_update_app_use_link_flag (tGATT_IF gatt_if, tGATT_TCB *p_tcb, BOOLEAN is_add, BOOLEAN check_acl_link)
333 {
334 GATT_TRACE_DEBUG("gatt_update_app_use_link_flag is_add=%d chk_link=%d",
335 is_add, check_acl_link);
336
337 gatt_update_app_hold_link_status(gatt_if, p_tcb, is_add);
338
339 if (check_acl_link &&
340 p_tcb &&
341 p_tcb->att_lcid == L2CAP_ATT_CID && /* only update link idle timer for fixed channel */
342 (BTM_GetHCIConnHandle(p_tcb->peer_bda, p_tcb->transport) != GATT_INVALID_ACL_HANDLE))
343 {
344 if (is_add)
345 {
346 GATT_TRACE_DEBUG("GATT disables link idle timer");
347 /* acl link is connected disable the idle timeout */
348 GATT_SetIdleTimeout(p_tcb->peer_bda, GATT_LINK_NO_IDLE_TIMEOUT, p_tcb->transport);
349 }
350 else
351 {
352 if (!gatt_num_apps_hold_link(p_tcb))
353 {
354 /* acl link is connected but no application needs to use the link
355 so set the timeout value to GATT_LINK_IDLE_TIMEOUT_WHEN_NO_APP seconds */
356 GATT_TRACE_DEBUG("GATT starts link idle timer =%d sec", GATT_LINK_IDLE_TIMEOUT_WHEN_NO_APP);
357 GATT_SetIdleTimeout(p_tcb->peer_bda, GATT_LINK_IDLE_TIMEOUT_WHEN_NO_APP, p_tcb->transport);
358 }
359
360 }
361 }
362 }
363
364 /*******************************************************************************
365 **
366 ** Function gatt_act_connect
367 **
368 ** Description GATT connection initiation.
369 **
370 ** Returns void.
371 **
372 *******************************************************************************/
gatt_act_connect(tGATT_REG * p_reg,BD_ADDR bd_addr,tBT_TRANSPORT transport)373 BOOLEAN gatt_act_connect (tGATT_REG *p_reg, BD_ADDR bd_addr, tBT_TRANSPORT transport)
374 {
375 BOOLEAN ret = FALSE;
376 tGATT_TCB *p_tcb;
377 UINT8 st;
378
379 if ((p_tcb = gatt_find_tcb_by_addr(bd_addr, transport)) != NULL)
380 {
381 ret = TRUE;
382 st = gatt_get_ch_state(p_tcb);
383
384 /* before link down, another app try to open a GATT connection */
385 if(st == GATT_CH_OPEN && gatt_num_apps_hold_link(p_tcb) == 0 &&
386 transport == BT_TRANSPORT_LE )
387 {
388 if (!gatt_connect(bd_addr, p_tcb, transport))
389 ret = FALSE;
390 }
391 else if(st == GATT_CH_CLOSING)
392 {
393 /* need to complete the closing first */
394 ret = FALSE;
395 }
396 }
397 else
398 {
399 if ((p_tcb = gatt_allocate_tcb_by_bdaddr(bd_addr, transport)) != NULL)
400 {
401 if (!gatt_connect(bd_addr, p_tcb, transport))
402 {
403 GATT_TRACE_ERROR("gatt_connect failed");
404 fixed_queue_free(p_tcb->pending_enc_clcb, NULL);
405 fixed_queue_free(p_tcb->pending_ind_q, NULL);
406 fixed_queue_free(p_tcb->sr_cmd.multi_rsp_q, NULL);
407 memset(p_tcb, 0, sizeof(tGATT_TCB));
408 }
409 else
410 ret = TRUE;
411 }
412 else
413 {
414 ret = 0;
415 GATT_TRACE_ERROR("Max TCB for gatt_if [%d] reached.", p_reg->gatt_if);
416 }
417 }
418
419 if (ret)
420 {
421 gatt_update_app_use_link_flag(p_reg->gatt_if, p_tcb, TRUE, FALSE);
422 }
423
424 return ret;
425 }
426
427 /*******************************************************************************
428 **
429 ** Function gatt_le_connect_cback
430 **
431 ** Description This callback function is called by L2CAP to indicate that
432 ** the ATT fixed channel for LE is
433 ** connected (conn = TRUE)/disconnected (conn = FALSE).
434 **
435 *******************************************************************************/
gatt_le_connect_cback(UINT16 chan,BD_ADDR bd_addr,BOOLEAN connected,UINT16 reason,tBT_TRANSPORT transport)436 static void gatt_le_connect_cback (UINT16 chan, BD_ADDR bd_addr, BOOLEAN connected,
437 UINT16 reason, tBT_TRANSPORT transport)
438 {
439
440 tGATT_TCB *p_tcb = gatt_find_tcb_by_addr(bd_addr, transport);
441 BOOLEAN check_srv_chg = FALSE;
442 tGATTS_SRV_CHG *p_srv_chg_clt=NULL;
443
444 /* ignore all fixed channel connect/disconnect on BR/EDR link for GATT */
445 if (transport == BT_TRANSPORT_BR_EDR)
446 return;
447
448 GATT_TRACE_DEBUG ("GATT ATT protocol channel with BDA: %08x%04x is %s",
449 (bd_addr[0]<<24)+(bd_addr[1]<<16)+(bd_addr[2]<<8)+bd_addr[3],
450 (bd_addr[4]<<8)+bd_addr[5], (connected) ? "connected" : "disconnected");
451
452 if ((p_srv_chg_clt = gatt_is_bda_in_the_srv_chg_clt_list(bd_addr)) != NULL)
453 {
454 check_srv_chg = TRUE;
455 }
456 else
457 {
458 if (btm_sec_is_a_bonded_dev(bd_addr))
459 gatt_add_a_bonded_dev_for_srv_chg(bd_addr);
460 }
461
462 if (connected)
463 {
464 /* do we have a channel initiating a connection? */
465 if (p_tcb)
466 {
467 /* we are initiating connection */
468 if ( gatt_get_ch_state(p_tcb) == GATT_CH_CONN)
469 {
470 /* send callback */
471 gatt_set_ch_state(p_tcb, GATT_CH_OPEN);
472 p_tcb->payload_size = GATT_DEF_BLE_MTU_SIZE;
473
474 gatt_send_conn_cback(p_tcb);
475 }
476 if (check_srv_chg)
477 gatt_chk_srv_chg (p_srv_chg_clt);
478 }
479 /* this is incoming connection or background connection callback */
480
481 else
482 {
483 if ((p_tcb = gatt_allocate_tcb_by_bdaddr(bd_addr, BT_TRANSPORT_LE)) != NULL)
484 {
485 p_tcb->att_lcid = L2CAP_ATT_CID;
486
487 gatt_set_ch_state(p_tcb, GATT_CH_OPEN);
488
489 p_tcb->payload_size = GATT_DEF_BLE_MTU_SIZE;
490
491 gatt_send_conn_cback (p_tcb);
492 if (check_srv_chg)
493 {
494 gatt_chk_srv_chg (p_srv_chg_clt);
495 }
496 }
497 else
498 {
499 GATT_TRACE_ERROR("CCB max out, no rsources");
500 }
501 }
502 }
503 else
504 {
505 gatt_cleanup_upon_disc(bd_addr, reason, transport);
506 GATT_TRACE_DEBUG ("ATT disconnected");
507 }
508 }
509
510 /*******************************************************************************
511 **
512 ** Function gatt_channel_congestion
513 **
514 ** Description This function is called to process the congestion callback
515 ** from lcb
516 **
517 ** Returns void
518 **
519 *******************************************************************************/
gatt_channel_congestion(tGATT_TCB * p_tcb,BOOLEAN congested)520 static void gatt_channel_congestion(tGATT_TCB *p_tcb, BOOLEAN congested)
521 {
522 UINT8 i = 0;
523 tGATT_REG *p_reg=NULL;
524 UINT16 conn_id;
525
526 /* if uncongested, check to see if there is any more pending data */
527 if (p_tcb != NULL && congested == FALSE)
528 {
529 gatt_cl_send_next_cmd_inq(p_tcb);
530 }
531 /* notifying all applications for the connection up event */
532 for (i = 0, p_reg = gatt_cb.cl_rcb ; i < GATT_MAX_APPS; i++, p_reg++)
533 {
534 if (p_reg->in_use)
535 {
536 if (p_reg->app_cb.p_congestion_cb)
537 {
538 conn_id = GATT_CREATE_CONN_ID(p_tcb->tcb_idx, p_reg->gatt_if);
539 (*p_reg->app_cb.p_congestion_cb)(conn_id, congested);
540 }
541 }
542 }
543 }
544
545 /*******************************************************************************
546 **
547 ** Function gatt_le_cong_cback
548 **
549 ** Description This function is called when GATT fixed channel is congested
550 ** or uncongested.
551 **
552 ** Returns void
553 **
554 *******************************************************************************/
gatt_le_cong_cback(BD_ADDR remote_bda,BOOLEAN congested)555 static void gatt_le_cong_cback(BD_ADDR remote_bda, BOOLEAN congested)
556 {
557 tGATT_TCB *p_tcb = gatt_find_tcb_by_addr(remote_bda, BT_TRANSPORT_LE);
558
559 /* if uncongested, check to see if there is any more pending data */
560 if (p_tcb != NULL)
561 {
562 gatt_channel_congestion(p_tcb, congested);
563 }
564 }
565
566 /*******************************************************************************
567 **
568 ** Function gatt_le_data_ind
569 **
570 ** Description This function is called when data is received from L2CAP.
571 ** if we are the originator of the connection, we are the ATT
572 ** client, and the received message is queued up for the client.
573 **
574 ** If we are the destination of the connection, we are the ATT
575 ** server, so the message is passed to the server processing
576 ** function.
577 **
578 ** Returns void
579 **
580 *******************************************************************************/
gatt_le_data_ind(UINT16 chan,BD_ADDR bd_addr,BT_HDR * p_buf)581 static void gatt_le_data_ind (UINT16 chan, BD_ADDR bd_addr, BT_HDR *p_buf)
582 {
583 tGATT_TCB *p_tcb;
584
585 /* Find CCB based on bd addr */
586 if ((p_tcb = gatt_find_tcb_by_addr (bd_addr, BT_TRANSPORT_LE)) != NULL &&
587 gatt_get_ch_state(p_tcb) >= GATT_CH_OPEN)
588 {
589 gatt_data_process(p_tcb, p_buf);
590 }
591 else
592 {
593 osi_free(p_buf);
594
595 if (p_tcb != NULL)
596 {
597 GATT_TRACE_WARNING ("ATT - Ignored L2CAP data while in state: %d",
598 gatt_get_ch_state(p_tcb));
599 }
600 }
601 }
602
603 /*******************************************************************************
604 **
605 ** Function gatt_l2cif_connect_ind
606 **
607 ** Description This function handles an inbound connection indication
608 ** from L2CAP. This is the case where we are acting as a
609 ** server.
610 **
611 ** Returns void
612 **
613 *******************************************************************************/
gatt_l2cif_connect_ind_cback(BD_ADDR bd_addr,UINT16 lcid,UINT16 psm,UINT8 id)614 static void gatt_l2cif_connect_ind_cback (BD_ADDR bd_addr, UINT16 lcid, UINT16 psm, UINT8 id)
615 {
616 /* do we already have a control channel for this peer? */
617 UINT8 result = L2CAP_CONN_OK;
618 tL2CAP_CFG_INFO cfg;
619 tGATT_TCB *p_tcb = gatt_find_tcb_by_addr(bd_addr, BT_TRANSPORT_BR_EDR);
620 UNUSED(psm);
621
622 GATT_TRACE_ERROR("Connection indication cid = %d", lcid);
623 /* new connection ? */
624 if (p_tcb == NULL)
625 {
626 /* allocate tcb */
627 if ((p_tcb = gatt_allocate_tcb_by_bdaddr(bd_addr, BT_TRANSPORT_BR_EDR)) == NULL)
628 {
629 /* no tcb available, reject L2CAP connection */
630 result = L2CAP_CONN_NO_RESOURCES;
631 }
632 else
633 p_tcb->att_lcid = lcid;
634
635 }
636 else /* existing connection , reject it */
637 {
638 result = L2CAP_CONN_NO_RESOURCES;
639 }
640
641 /* Send L2CAP connect rsp */
642 L2CA_ConnectRsp(bd_addr, id, lcid, result, 0);
643
644 /* if result ok, proceed with connection */
645 if (result == L2CAP_CONN_OK)
646 {
647 /* transition to configuration state */
648 gatt_set_ch_state(p_tcb, GATT_CH_CFG);
649
650 /* Send L2CAP config req */
651 memset(&cfg, 0, sizeof(tL2CAP_CFG_INFO));
652 cfg.mtu_present = TRUE;
653 cfg.mtu = GATT_MAX_MTU_SIZE;
654
655 L2CA_ConfigReq(lcid, &cfg);
656 }
657 }
658
659 /*******************************************************************************
660 **
661 ** Function gatt_l2c_connect_cfm_cback
662 **
663 ** Description This is the L2CAP connect confirm callback function.
664 **
665 **
666 ** Returns void
667 **
668 *******************************************************************************/
gatt_l2cif_connect_cfm_cback(UINT16 lcid,UINT16 result)669 static void gatt_l2cif_connect_cfm_cback(UINT16 lcid, UINT16 result)
670 {
671 tGATT_TCB *p_tcb;
672 tL2CAP_CFG_INFO cfg;
673
674 /* look up clcb for this channel */
675 if ((p_tcb = gatt_find_tcb_by_cid(lcid)) != NULL)
676 {
677 GATT_TRACE_DEBUG("gatt_l2c_connect_cfm_cback result: %d ch_state: %d, lcid:0x%x", result, gatt_get_ch_state(p_tcb), p_tcb->att_lcid);
678
679 /* if in correct state */
680 if (gatt_get_ch_state(p_tcb) == GATT_CH_CONN)
681 {
682 /* if result successful */
683 if (result == L2CAP_CONN_OK)
684 {
685 /* set channel state */
686 gatt_set_ch_state(p_tcb, GATT_CH_CFG);
687
688 /* Send L2CAP config req */
689 memset(&cfg, 0, sizeof(tL2CAP_CFG_INFO));
690 cfg.mtu_present = TRUE;
691 cfg.mtu = GATT_MAX_MTU_SIZE;
692 L2CA_ConfigReq(lcid, &cfg);
693 }
694 /* else initiating connection failure */
695 else
696 {
697 gatt_cleanup_upon_disc(p_tcb->peer_bda, result, GATT_TRANSPORT_BR_EDR);
698 }
699 }
700 else /* wrong state, disconnect it */
701 {
702 if (result == L2CAP_CONN_OK)
703 {
704 /* just in case the peer also accepts our connection - Send L2CAP disconnect req */
705 L2CA_DisconnectReq(lcid);
706 }
707 }
708 }
709 }
710
711 /*******************************************************************************
712 **
713 ** Function gatt_l2cif_config_cfm_cback
714 **
715 ** Description This is the L2CAP config confirm callback function.
716 **
717 **
718 ** Returns void
719 **
720 *******************************************************************************/
gatt_l2cif_config_cfm_cback(UINT16 lcid,tL2CAP_CFG_INFO * p_cfg)721 void gatt_l2cif_config_cfm_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg)
722 {
723 tGATT_TCB *p_tcb;
724 tGATTS_SRV_CHG *p_srv_chg_clt=NULL;
725
726 /* look up clcb for this channel */
727 if ((p_tcb = gatt_find_tcb_by_cid(lcid)) != NULL)
728 {
729 /* if in correct state */
730 if ( gatt_get_ch_state(p_tcb) == GATT_CH_CFG)
731 {
732 /* if result successful */
733 if (p_cfg->result == L2CAP_CFG_OK)
734 {
735 /* update flags */
736 p_tcb->ch_flags |= GATT_L2C_CFG_CFM_DONE;
737
738 /* if configuration complete */
739 if (p_tcb->ch_flags & GATT_L2C_CFG_IND_DONE)
740 {
741 gatt_set_ch_state(p_tcb, GATT_CH_OPEN);
742
743 if ((p_srv_chg_clt = gatt_is_bda_in_the_srv_chg_clt_list(p_tcb->peer_bda)) != NULL)
744 {
745 gatt_chk_srv_chg(p_srv_chg_clt);
746 }
747 else
748 {
749 if (btm_sec_is_a_bonded_dev(p_tcb->peer_bda))
750 gatt_add_a_bonded_dev_for_srv_chg(p_tcb->peer_bda);
751 }
752
753 /* send callback */
754 gatt_send_conn_cback(p_tcb);
755 }
756 }
757 /* else failure */
758 else
759 {
760 /* Send L2CAP disconnect req */
761 L2CA_DisconnectReq(lcid);
762 }
763 }
764 }
765 }
766
767 /*******************************************************************************
768 **
769 ** Function gatt_l2cif_config_ind_cback
770 **
771 ** Description This is the L2CAP config indication callback function.
772 **
773 **
774 ** Returns void
775 **
776 *******************************************************************************/
gatt_l2cif_config_ind_cback(UINT16 lcid,tL2CAP_CFG_INFO * p_cfg)777 void gatt_l2cif_config_ind_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg)
778 {
779 tGATT_TCB *p_tcb;
780 tGATTS_SRV_CHG *p_srv_chg_clt=NULL;
781 /* look up clcb for this channel */
782 if ((p_tcb = gatt_find_tcb_by_cid(lcid)) != NULL)
783 {
784 /* GATT uses the smaller of our MTU and peer's MTU */
785 if ( p_cfg->mtu_present &&
786 (p_cfg->mtu >= GATT_MIN_BR_MTU_SIZE && p_cfg->mtu < L2CAP_DEFAULT_MTU))
787 p_tcb->payload_size = p_cfg->mtu;
788 else
789 p_tcb->payload_size = L2CAP_DEFAULT_MTU;
790
791 /* send L2CAP configure response */
792 memset(p_cfg, 0, sizeof(tL2CAP_CFG_INFO));
793 p_cfg->result = L2CAP_CFG_OK;
794 L2CA_ConfigRsp(lcid, p_cfg);
795
796 /* if first config ind */
797 if ((p_tcb->ch_flags & GATT_L2C_CFG_IND_DONE) == 0)
798 {
799 /* update flags */
800 p_tcb->ch_flags |= GATT_L2C_CFG_IND_DONE;
801
802 /* if configuration complete */
803 if (p_tcb->ch_flags & GATT_L2C_CFG_CFM_DONE)
804 {
805 gatt_set_ch_state(p_tcb, GATT_CH_OPEN);
806 if ((p_srv_chg_clt = gatt_is_bda_in_the_srv_chg_clt_list(p_tcb->peer_bda)) != NULL)
807 {
808 gatt_chk_srv_chg(p_srv_chg_clt);
809 }
810 else
811 {
812 if (btm_sec_is_a_bonded_dev(p_tcb->peer_bda))
813 gatt_add_a_bonded_dev_for_srv_chg(p_tcb->peer_bda);
814 }
815
816 /* send callback */
817 gatt_send_conn_cback(p_tcb);
818 }
819 }
820 }
821 }
822
823 /*******************************************************************************
824 **
825 ** Function gatt_l2cif_disconnect_ind_cback
826 **
827 ** Description This is the L2CAP disconnect indication callback function.
828 **
829 **
830 ** Returns void
831 **
832 *******************************************************************************/
gatt_l2cif_disconnect_ind_cback(UINT16 lcid,BOOLEAN ack_needed)833 void gatt_l2cif_disconnect_ind_cback(UINT16 lcid, BOOLEAN ack_needed)
834 {
835 tGATT_TCB *p_tcb;
836 UINT16 reason;
837
838 /* look up clcb for this channel */
839 if ((p_tcb = gatt_find_tcb_by_cid(lcid)) != NULL)
840 {
841 if (ack_needed)
842 {
843 /* send L2CAP disconnect response */
844 L2CA_DisconnectRsp(lcid);
845 }
846 if (gatt_is_bda_in_the_srv_chg_clt_list(p_tcb->peer_bda) == NULL)
847 {
848 if (btm_sec_is_a_bonded_dev(p_tcb->peer_bda))
849 gatt_add_a_bonded_dev_for_srv_chg(p_tcb->peer_bda);
850 }
851 /* if ACL link is still up, no reason is logged, l2cap is disconnect from peer */
852 if ((reason = L2CA_GetDisconnectReason(p_tcb->peer_bda, p_tcb->transport)) == 0)
853 reason = GATT_CONN_TERMINATE_PEER_USER;
854
855 /* send disconnect callback */
856 gatt_cleanup_upon_disc(p_tcb->peer_bda, reason, GATT_TRANSPORT_BR_EDR);
857 }
858 }
859
860 /*******************************************************************************
861 **
862 ** Function gatt_l2cif_disconnect_cfm_cback
863 **
864 ** Description This is the L2CAP disconnect confirm callback function.
865 **
866 **
867 ** Returns void
868 **
869 *******************************************************************************/
gatt_l2cif_disconnect_cfm_cback(UINT16 lcid,UINT16 result)870 static void gatt_l2cif_disconnect_cfm_cback(UINT16 lcid, UINT16 result)
871 {
872 tGATT_TCB *p_tcb;
873 UINT16 reason;
874 UNUSED(result);
875
876 /* look up clcb for this channel */
877 if ((p_tcb = gatt_find_tcb_by_cid(lcid)) != NULL)
878 {
879 /* If the device is not in the service changed client list, add it... */
880 if (gatt_is_bda_in_the_srv_chg_clt_list(p_tcb->peer_bda) == NULL)
881 {
882 if (btm_sec_is_a_bonded_dev(p_tcb->peer_bda))
883 gatt_add_a_bonded_dev_for_srv_chg(p_tcb->peer_bda);
884 }
885
886 /* send disconnect callback */
887 /* if ACL link is still up, no reason is logged, l2cap is disconnect from peer */
888 if ((reason = L2CA_GetDisconnectReason(p_tcb->peer_bda, p_tcb->transport)) == 0)
889 reason = GATT_CONN_TERMINATE_LOCAL_HOST;
890
891 gatt_cleanup_upon_disc(p_tcb->peer_bda, reason, GATT_TRANSPORT_BR_EDR);
892 }
893 }
894
895 /*******************************************************************************
896 **
897 ** Function gatt_l2cif_data_ind_cback
898 **
899 ** Description This is the L2CAP data indication callback function.
900 **
901 **
902 ** Returns void
903 **
904 *******************************************************************************/
gatt_l2cif_data_ind_cback(UINT16 lcid,BT_HDR * p_buf)905 static void gatt_l2cif_data_ind_cback(UINT16 lcid, BT_HDR *p_buf)
906 {
907 tGATT_TCB *p_tcb;
908
909 /* look up clcb for this channel */
910 if ((p_tcb = gatt_find_tcb_by_cid(lcid)) != NULL &&
911 gatt_get_ch_state(p_tcb) == GATT_CH_OPEN)
912 {
913 /* process the data */
914 gatt_data_process(p_tcb, p_buf);
915 }
916 else /* prevent buffer leak */
917 osi_free(p_buf);
918 }
919
920 /*******************************************************************************
921 **
922 ** Function gatt_l2cif_congest_cback
923 **
924 ** Description L2CAP congestion callback
925 **
926 ** Returns void
927 **
928 *******************************************************************************/
gatt_l2cif_congest_cback(UINT16 lcid,BOOLEAN congested)929 static void gatt_l2cif_congest_cback (UINT16 lcid, BOOLEAN congested)
930 {
931 tGATT_TCB *p_tcb = gatt_find_tcb_by_cid(lcid);
932
933 if (p_tcb != NULL)
934 {
935 gatt_channel_congestion(p_tcb, congested);
936 }
937 }
938
939 /*******************************************************************************
940 **
941 ** Function gatt_send_conn_cback
942 **
943 ** Description Callback used to notify layer above about a connection.
944 **
945 **
946 ** Returns void
947 **
948 *******************************************************************************/
gatt_send_conn_cback(tGATT_TCB * p_tcb)949 static void gatt_send_conn_cback(tGATT_TCB *p_tcb)
950 {
951 UINT8 i;
952 tGATT_REG *p_reg;
953 tGATT_BG_CONN_DEV *p_bg_dev=NULL;
954 UINT16 conn_id;
955
956 p_bg_dev = gatt_find_bg_dev(p_tcb->peer_bda);
957
958 /* notifying all applications for the connection up event */
959 for (i = 0, p_reg = gatt_cb.cl_rcb ; i < GATT_MAX_APPS; i++, p_reg++)
960 {
961 if (p_reg->in_use)
962 {
963 if (p_bg_dev && gatt_is_bg_dev_for_app(p_bg_dev, p_reg->gatt_if))
964 gatt_update_app_use_link_flag(p_reg->gatt_if, p_tcb, TRUE, TRUE);
965
966 if (p_reg->app_cb.p_conn_cb)
967 {
968 conn_id = GATT_CREATE_CONN_ID(p_tcb->tcb_idx, p_reg->gatt_if);
969 (*p_reg->app_cb.p_conn_cb)(p_reg->gatt_if, p_tcb->peer_bda, conn_id,
970 TRUE, 0, p_tcb->transport);
971 }
972 }
973 }
974
975
976 if (gatt_num_apps_hold_link(p_tcb) && p_tcb->att_lcid == L2CAP_ATT_CID )
977 {
978 /* disable idle timeout if one or more clients are holding the link disable the idle timer */
979 GATT_SetIdleTimeout(p_tcb->peer_bda, GATT_LINK_NO_IDLE_TIMEOUT, p_tcb->transport);
980 }
981 }
982
983 /*******************************************************************************
984 **
985 ** Function gatt_le_data_ind
986 **
987 ** Description This function is called when data is received from L2CAP.
988 ** if we are the originator of the connection, we are the ATT
989 ** client, and the received message is queued up for the client.
990 **
991 ** If we are the destination of the connection, we are the ATT
992 ** server, so the message is passed to the server processing
993 ** function.
994 **
995 ** Returns void
996 **
997 *******************************************************************************/
gatt_data_process(tGATT_TCB * p_tcb,BT_HDR * p_buf)998 void gatt_data_process (tGATT_TCB *p_tcb, BT_HDR *p_buf)
999 {
1000 UINT8 *p = (UINT8 *)(p_buf + 1) + p_buf->offset;
1001 UINT8 op_code, pseudo_op_code;
1002 UINT16 msg_len;
1003
1004
1005 if (p_buf->len > 0)
1006 {
1007 msg_len = p_buf->len - 1;
1008 STREAM_TO_UINT8(op_code, p);
1009
1010 /* remove the two MSBs associated with sign write and write cmd */
1011 pseudo_op_code = op_code & (~GATT_WRITE_CMD_MASK);
1012
1013 if (pseudo_op_code < GATT_OP_CODE_MAX)
1014 {
1015 if (op_code == GATT_SIGN_CMD_WRITE)
1016 {
1017 gatt_verify_signature(p_tcb, p_buf);
1018 }
1019 else
1020 {
1021 /* message from client */
1022 if ((op_code % 2) == 0)
1023 gatt_server_handle_client_req (p_tcb, op_code, msg_len, p);
1024 else
1025 gatt_client_handle_server_rsp (p_tcb, op_code, msg_len, p);
1026 }
1027 }
1028 else
1029 {
1030 GATT_TRACE_ERROR ("ATT - Rcvd L2CAP data, unknown cmd: 0x%x", op_code);
1031 }
1032 }
1033 else
1034 {
1035 GATT_TRACE_ERROR ("invalid data length, ignore");
1036 }
1037
1038 osi_free(p_buf);
1039 }
1040
1041 /*******************************************************************************
1042 **
1043 ** Function gatt_add_a_bonded_dev_for_srv_chg
1044 **
1045 ** Description Add a bonded dev to the service changed client list
1046 **
1047 ** Returns void
1048 **
1049 *******************************************************************************/
gatt_add_a_bonded_dev_for_srv_chg(BD_ADDR bda)1050 void gatt_add_a_bonded_dev_for_srv_chg (BD_ADDR bda)
1051 {
1052 tGATTS_SRV_CHG_REQ req;
1053 tGATTS_SRV_CHG srv_chg_clt;
1054
1055 memcpy(srv_chg_clt.bda, bda, BD_ADDR_LEN);
1056 srv_chg_clt.srv_changed = FALSE;
1057 if (gatt_add_srv_chg_clt(&srv_chg_clt) != NULL)
1058 {
1059 memcpy(req.srv_chg.bda, bda, BD_ADDR_LEN);
1060 req.srv_chg.srv_changed = FALSE;
1061 if (gatt_cb.cb_info.p_srv_chg_callback)
1062 (*gatt_cb.cb_info.p_srv_chg_callback)(GATTS_SRV_CHG_CMD_ADD_CLIENT, &req, NULL);
1063 }
1064 }
1065
1066 /*******************************************************************************
1067 **
1068 ** Function gatt_send_srv_chg_ind
1069 **
1070 ** Description This function is called to send a service chnaged indication to
1071 ** the specified bd address
1072 **
1073 ** Returns void
1074 **
1075 *******************************************************************************/
gatt_send_srv_chg_ind(BD_ADDR peer_bda)1076 void gatt_send_srv_chg_ind (BD_ADDR peer_bda)
1077 {
1078 UINT8 handle_range[GATT_SIZE_OF_SRV_CHG_HNDL_RANGE];
1079 UINT8 *p = handle_range;
1080 UINT16 conn_id;
1081
1082 GATT_TRACE_DEBUG("gatt_send_srv_chg_ind");
1083
1084 if (gatt_cb.handle_of_h_r)
1085 {
1086 if ((conn_id = gatt_profile_find_conn_id_by_bd_addr(peer_bda)) != GATT_INVALID_CONN_ID)
1087 {
1088 UINT16_TO_STREAM (p, 1);
1089 UINT16_TO_STREAM (p, 0xFFFF);
1090 GATTS_HandleValueIndication (conn_id,
1091 gatt_cb.handle_of_h_r,
1092 GATT_SIZE_OF_SRV_CHG_HNDL_RANGE,
1093 handle_range);
1094 }
1095 else
1096 {
1097 GATT_TRACE_ERROR("Unable to find conn_id for %08x%04x ",
1098 (peer_bda[0]<<24)+(peer_bda[1]<<16)+(peer_bda[2]<<8)+peer_bda[3],
1099 (peer_bda[4]<<8)+peer_bda[5] );
1100 }
1101 }
1102 }
1103
1104 /*******************************************************************************
1105 **
1106 ** Function gatt_chk_srv_chg
1107 **
1108 ** Description Check sending service chnaged Indication is required or not
1109 ** if required then send the Indication
1110 **
1111 ** Returns void
1112 **
1113 *******************************************************************************/
gatt_chk_srv_chg(tGATTS_SRV_CHG * p_srv_chg_clt)1114 void gatt_chk_srv_chg(tGATTS_SRV_CHG *p_srv_chg_clt)
1115 {
1116 GATT_TRACE_DEBUG("gatt_chk_srv_chg srv_changed=%d", p_srv_chg_clt->srv_changed );
1117
1118 if (p_srv_chg_clt->srv_changed)
1119 {
1120 gatt_send_srv_chg_ind(p_srv_chg_clt->bda);
1121 }
1122 }
1123
1124 /*******************************************************************************
1125 **
1126 ** Function gatt_init_srv_chg
1127 **
1128 ** Description This function is used to initialize the service changed
1129 ** attribute value
1130 **
1131 ** Returns void
1132 **
1133 *******************************************************************************/
gatt_init_srv_chg(void)1134 void gatt_init_srv_chg (void)
1135 {
1136 tGATTS_SRV_CHG_REQ req;
1137 tGATTS_SRV_CHG_RSP rsp;
1138 BOOLEAN status;
1139 UINT8 num_clients,i;
1140 tGATTS_SRV_CHG srv_chg_clt;
1141
1142 GATT_TRACE_DEBUG("gatt_init_srv_chg");
1143 if (gatt_cb.cb_info.p_srv_chg_callback)
1144 {
1145 status = (*gatt_cb.cb_info.p_srv_chg_callback)(GATTS_SRV_CHG_CMD_READ_NUM_CLENTS, NULL, &rsp);
1146
1147 if (status && rsp.num_clients)
1148 {
1149 GATT_TRACE_DEBUG("gatt_init_srv_chg num_srv_chg_clt_clients=%d", rsp.num_clients);
1150 num_clients = rsp.num_clients;
1151 i = 1; /* use one based index */
1152 while ((i <= num_clients) && status)
1153 {
1154 req.client_read_index = i;
1155 if ((status = (*gatt_cb.cb_info.p_srv_chg_callback)(GATTS_SRV_CHG_CMD_READ_CLENT, &req, &rsp)) == TRUE)
1156 {
1157 memcpy(&srv_chg_clt, &rsp.srv_chg ,sizeof(tGATTS_SRV_CHG));
1158 if (gatt_add_srv_chg_clt(&srv_chg_clt) == NULL)
1159 {
1160 GATT_TRACE_ERROR("Unable to add a service change client");
1161 status = FALSE;
1162 }
1163 }
1164 i++;
1165 }
1166 }
1167 }
1168 else
1169 {
1170 GATT_TRACE_DEBUG("gatt_init_srv_chg callback not registered yet");
1171 }
1172 }
1173
1174 /*******************************************************************************
1175 **
1176 ** Function gatt_proc_srv_chg
1177 **
1178 ** Description This function is process the service changed request
1179 **
1180 ** Returns void
1181 **
1182 *******************************************************************************/
gatt_proc_srv_chg(void)1183 void gatt_proc_srv_chg (void)
1184 {
1185 UINT8 start_idx, found_idx;
1186 BD_ADDR bda;
1187 BOOLEAN srv_chg_ind_pending=FALSE;
1188 tGATT_TCB *p_tcb;
1189 tBT_TRANSPORT transport;
1190
1191 GATT_TRACE_DEBUG ("gatt_proc_srv_chg");
1192
1193 if (gatt_cb.cb_info.p_srv_chg_callback && gatt_cb.handle_of_h_r)
1194 {
1195 gatt_set_srv_chg();
1196 start_idx =0;
1197 while (gatt_find_the_connected_bda(start_idx, bda, &found_idx, &transport))
1198 {
1199 p_tcb = &gatt_cb.tcb[found_idx];;
1200 srv_chg_ind_pending = gatt_is_srv_chg_ind_pending(p_tcb);
1201
1202 if (!srv_chg_ind_pending)
1203 {
1204 gatt_send_srv_chg_ind(bda);
1205 }
1206 else
1207 {
1208 GATT_TRACE_DEBUG ("discard srv chg - already has one in the queue");
1209 }
1210 start_idx = ++found_idx;
1211 }
1212 }
1213 }
1214
1215 /*******************************************************************************
1216 **
1217 ** Function gatt_set_ch_state
1218 **
1219 ** Description This function set the ch_state in tcb
1220 **
1221 ** Returns none
1222 **
1223 *******************************************************************************/
gatt_set_ch_state(tGATT_TCB * p_tcb,tGATT_CH_STATE ch_state)1224 void gatt_set_ch_state(tGATT_TCB *p_tcb, tGATT_CH_STATE ch_state)
1225 {
1226 if (p_tcb)
1227 {
1228 GATT_TRACE_DEBUG ("gatt_set_ch_state: old=%d new=%d", p_tcb->ch_state, ch_state);
1229 p_tcb->ch_state = ch_state;
1230 }
1231 }
1232
1233 /*******************************************************************************
1234 **
1235 ** Function gatt_get_ch_state
1236 **
1237 ** Description This function get the ch_state in tcb
1238 **
1239 ** Returns none
1240 **
1241 *******************************************************************************/
gatt_get_ch_state(tGATT_TCB * p_tcb)1242 tGATT_CH_STATE gatt_get_ch_state(tGATT_TCB *p_tcb)
1243 {
1244 tGATT_CH_STATE ch_state = GATT_CH_CLOSE;
1245 if (p_tcb)
1246 {
1247 GATT_TRACE_DEBUG ("gatt_get_ch_state: ch_state=%d", p_tcb->ch_state);
1248 ch_state = p_tcb->ch_state;
1249 }
1250 return ch_state;
1251 }
1252
1253 #endif /* BLE_INCLUDED */
1254