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