stack/gatt/gatt_main.c

   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 *******************************************************************************/
  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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
 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 *******************************************************************************/
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 *******************************************************************************/
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 *******************************************************************************/
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 *******************************************************************************/
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 *******************************************************************************/
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 *******************************************************************************/
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 *******************************************************************************/
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 */