bta/gatt/bta_gattc_utils.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 2003-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 GATT client utility function.
  22  *
  23  ******************************************************************************/
  24
  25 #define LOG_TAG "bt_bta_gattc"
  26
  27 #include "bt_target.h"
  28
  29 #if defined(BTA_GATT_INCLUDED) && (BTA_GATT_INCLUDED == TRUE)
  30
  31 #include <string.h>
  32
  33 #include "bta_gattc_int.h"
  34 #include "bta_sys.h"
  35 #include "btcore/include/bdaddr.h"
  36 #include "btif/include/btif_util.h"
  37 #include "gki.h"
  38 #include "l2c_api.h"
  39 #include "utl.h"
  40
  41 /*****************************************************************************
  42 **  Constants
  43 *****************************************************************************/
  44
  45 static const UINT8  base_uuid[LEN_UUID_128] = {0xFB, 0x34, 0x9B, 0x5F, 0x80, 0x00, 0x00, 0x80,
  46     0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  47
  48 static const BD_ADDR dummy_bda = {0,0,0,0,0,0};
  49
  50 /*******************************************************************************
  51 **
  52 ** Function         bta_gatt_convert_uuid16_to_uuid128
  53 **
  54 ** Description      Convert a 16 bits UUID to be an standard 128 bits one.
  55 **
  56 ** Returns          TRUE if two uuid match; FALSE otherwise.
  57 **
  58 *******************************************************************************/
  59 void bta_gatt_convert_uuid16_to_uuid128(UINT8 uuid_128[LEN_UUID_128], UINT16 uuid_16)
  60 {
  61     UINT8   *p = &uuid_128[LEN_UUID_128 - 4];
  62
  63     memcpy (uuid_128, base_uuid, LEN_UUID_128);
  64
  65     UINT16_TO_STREAM(p, uuid_16);
  66 }
  67 /*******************************************************************************
  68 **
  69 ** Function         bta_gattc_uuid_compare
  70 **
  71 ** Description      Compare two UUID to see if they are the same.
  72 **
  73 ** Returns          TRUE if two uuid match; FALSE otherwise.
  74 **
  75 *******************************************************************************/
  76 BOOLEAN bta_gattc_uuid_compare (tBT_UUID *p_src, tBT_UUID *p_tar, BOOLEAN is_precise)
  77 {
  78     UINT8  su[LEN_UUID_128], tu[LEN_UUID_128];
  79     UINT8  *ps, *pt;
  80
  81     /* any of the UUID is unspecified */
  82     if (p_src == 0 || p_tar == 0)
  83     {
  84         if (is_precise)
  85             return FALSE;
  86         else
  87             return TRUE;
  88     }
  89
  90     /* If both are 16-bit, we can do a simple compare */
  91     if (p_src->len == 2 && p_tar->len == 2)
  92     {
  93         return p_src->uu.uuid16 == p_tar->uu.uuid16;
  94     }
  95
  96     /* One or both of the UUIDs is 128-bit */
  97     if (p_src->len == LEN_UUID_16)
  98     {
  99         /* convert a 16 bits UUID to 128 bits value */
 100         bta_gatt_convert_uuid16_to_uuid128(su, p_src->uu.uuid16);
 101         ps = su;
 102     }
 103     else
 104         ps = p_src->uu.uuid128;
 105
 106     if (p_tar->len == LEN_UUID_16)
 107     {
 108         /* convert a 16 bits UUID to 128 bits value */
 109         bta_gatt_convert_uuid16_to_uuid128(tu, p_tar->uu.uuid16);
 110         pt = tu;
 111     }
 112     else
 113         pt = p_tar->uu.uuid128;
 114
 115     return(memcmp(ps, pt, LEN_UUID_128) == 0);
 116 }
 117
 118 /*******************************************************************************
 119 **
 120 ** Function         bta_gattc_cl_get_regcb
 121 **
 122 ** Description      get registration control block by client interface.
 123 **
 124 ** Returns          pointer to the regcb
 125 **
 126 *******************************************************************************/
 127 tBTA_GATTC_RCB * bta_gattc_cl_get_regcb(UINT8 client_if)
 128 {
 129     UINT8   i = 0;
 130     tBTA_GATTC_RCB  *p_clrcb = &bta_gattc_cb.cl_rcb[0];
 131
 132     for (i = 0; i < BTA_GATTC_CL_MAX; i ++, p_clrcb ++)
 133     {
 134         if (p_clrcb->in_use &&
 135             p_clrcb->client_if == client_if)
 136             return p_clrcb;
 137     }
 138     return NULL;
 139 }
 140 /*******************************************************************************
 141 **
 142 ** Function         bta_gattc_num_reg_app
 143 **
 144 ** Description      find the number of registered application.
 145 **
 146 ** Returns          pointer to the regcb
 147 **
 148 *******************************************************************************/
 149 UINT8 bta_gattc_num_reg_app(void)
 150 {
 151     UINT8   i = 0, j = 0;
 152
 153     for (i = 0; i < BTA_GATTC_CL_MAX; i ++)
 154     {
 155         if (bta_gattc_cb.cl_rcb[i].in_use)
 156             j ++;
 157     }
 158     return j;
 159 }
 160 /*******************************************************************************
 161 **
 162 ** Function         bta_gattc_find_clcb_by_cif
 163 **
 164 ** Description      get clcb by client interface and remote bd adddress
 165 **
 166 ** Returns          pointer to the clcb
 167 **
 168 *******************************************************************************/
 169 tBTA_GATTC_CLCB * bta_gattc_find_clcb_by_cif (UINT8 client_if, BD_ADDR remote_bda,
 170                                               tBTA_TRANSPORT transport)
 171 {
 172     tBTA_GATTC_CLCB *p_clcb = &bta_gattc_cb.clcb[0];
 173     UINT8   i;
 174
 175     for (i = 0; i < BTA_GATTC_CLCB_MAX; i ++, p_clcb ++)
 176     {
 177         if (p_clcb->in_use &&
 178             p_clcb->p_rcb->client_if == client_if &&
 179             p_clcb->transport == transport &&
 180             bdcmp(p_clcb->bda, remote_bda) == 0)
 181             return p_clcb;
 182     }
 183     return NULL;
 184 }
 185 /*******************************************************************************
 186 **
 187 ** Function         bta_gattc_find_clcb_by_conn_id
 188 **
 189 ** Description      get clcb by connection ID
 190 **
 191 ** Returns          pointer to the clcb
 192 **
 193 *******************************************************************************/
 194 tBTA_GATTC_CLCB * bta_gattc_find_clcb_by_conn_id (UINT16 conn_id)
 195 {
 196     tBTA_GATTC_CLCB *p_clcb = &bta_gattc_cb.clcb[0];
 197     UINT8 i;
 198
 199     for (i = 0; i < BTA_GATTC_CLCB_MAX; i ++, p_clcb ++)
 200     {
 201         if (p_clcb->in_use &&
 202             p_clcb->bta_conn_id == conn_id)
 203             return p_clcb;
 204     }
 205     return NULL;
 206 }
 207
 208 /*******************************************************************************
 209 **
 210 ** Function         bta_gattc_clcb_alloc
 211 **
 212 ** Description      allocate CLCB
 213 **
 214 ** Returns          pointer to the clcb
 215 **
 216 *******************************************************************************/
 217 tBTA_GATTC_CLCB * bta_gattc_clcb_alloc(tBTA_GATTC_IF client_if, BD_ADDR remote_bda,
 218                                        tBTA_TRANSPORT transport)
 219 {
 220     UINT8               i_clcb = 0;
 221     tBTA_GATTC_CLCB     *p_clcb = NULL;
 222
 223     for (i_clcb = 0; i_clcb < BTA_GATTC_CLCB_MAX; i_clcb++)
 224     {
 225         if (!bta_gattc_cb.clcb[i_clcb].in_use)
 226         {
 227 #if BTA_GATT_DEBUG == TRUE
 228             APPL_TRACE_DEBUG("bta_gattc_clcb_alloc: found clcb[%d] available",i_clcb);
 229 #endif
 230             p_clcb                  = &bta_gattc_cb.clcb[i_clcb];
 231             p_clcb->in_use          = TRUE;
 232             p_clcb->status          = BTA_GATT_OK;
 233             p_clcb->transport       = transport;
 234             bdcpy(p_clcb->bda, remote_bda);
 235
 236             p_clcb->p_rcb = bta_gattc_cl_get_regcb(client_if);
 237
 238             if ((p_clcb->p_srcb = bta_gattc_find_srcb(remote_bda)) == NULL)
 239                 p_clcb->p_srcb      = bta_gattc_srcb_alloc(remote_bda);
 240
 241             if (p_clcb->p_rcb != NULL && p_clcb->p_srcb != NULL)
 242             {
 243                 p_clcb->p_srcb->num_clcb ++;
 244                 p_clcb->p_rcb->num_clcb ++;
 245             }
 246             else
 247             {
 248                 /* release this clcb if clcb or srcb allocation failed */
 249                 p_clcb->in_use = FALSE;
 250                 p_clcb = NULL;
 251             }
 252             break;
 253         }
 254     }
 255     return p_clcb;
 256 }
 257 /*******************************************************************************
 258 **
 259 ** Function         bta_gattc_find_alloc_clcb
 260 **
 261 ** Description      find or allocate CLCB if not found.
 262 **
 263 ** Returns          pointer to the clcb
 264 **
 265 *******************************************************************************/
 266 tBTA_GATTC_CLCB *bta_gattc_find_alloc_clcb(tBTA_GATTC_IF client_if, BD_ADDR remote_bda,
 267                                            tBTA_TRANSPORT transport)
 268 {
 269     tBTA_GATTC_CLCB *p_clcb ;
 270
 271     if ((p_clcb = bta_gattc_find_clcb_by_cif(client_if, remote_bda, transport)) == NULL)
 272     {
 273         p_clcb = bta_gattc_clcb_alloc(client_if, remote_bda, transport);
 274     }
 275     return p_clcb;
 276 }
 277
 278 /*******************************************************************************
 279 **
 280 ** Function         bta_gattc_clcb_dealloc
 281 **
 282 ** Description      Deallocte a clcb
 283 **
 284 ** Returns          pointer to the clcb
 285 **
 286 *******************************************************************************/
 287 void bta_gattc_clcb_dealloc(tBTA_GATTC_CLCB *p_clcb)
 288 {
 289     tBTA_GATTC_SERV     *p_srcb = NULL;
 290
 291     if (p_clcb)
 292     {
 293         p_srcb = p_clcb->p_srcb;
 294         if (p_srcb->num_clcb)
 295             p_srcb->num_clcb --;
 296
 297         if (p_clcb->p_rcb->num_clcb)
 298             p_clcb->p_rcb->num_clcb --;
 299
 300         /* if the srcb is no longer needed, reset the state */
 301         if ( p_srcb->num_clcb == 0)
 302         {
 303             p_srcb->connected = FALSE;
 304             p_srcb->state = BTA_GATTC_SERV_IDLE;
 305             p_srcb->mtu = 0;
 306         }
 307
 308         utl_freebuf((void **)&p_clcb->p_q_cmd);
 309
 310         memset(p_clcb, 0, sizeof(tBTA_GATTC_CLCB));
 311     }
 312     else
 313     {
 314         APPL_TRACE_ERROR("bta_gattc_clcb_dealloc p_clcb=NULL");
 315     }
 316 }
 317
 318 /*******************************************************************************
 319 **
 320 ** Function         bta_gattc_find_srcb
 321 **
 322 ** Description      find server cache by remote bd address currently in use
 323 **
 324 ** Returns          pointer to the server cache.
 325 **
 326 *******************************************************************************/
 327 tBTA_GATTC_SERV * bta_gattc_find_srcb(BD_ADDR bda)
 328 {
 329     tBTA_GATTC_SERV *p_srcb = &bta_gattc_cb.known_server[0];
 330     UINT8   i;
 331
 332     for (i = 0; i < BTA_GATTC_KNOWN_SR_MAX; i ++, p_srcb ++)
 333     {
 334         if (p_srcb->in_use && bdcmp(p_srcb->server_bda, bda) == 0)
 335             return p_srcb;
 336     }
 337     return NULL;
 338 }
 339
 340 /*******************************************************************************
 341 **
 342 ** Function         bta_gattc_find_srvr_cache
 343 **
 344 ** Description      find server cache by remote bd address
 345 **
 346 ** Returns          pointer to the server cache.
 347 **
 348 *******************************************************************************/
 349 tBTA_GATTC_SERV * bta_gattc_find_srvr_cache(BD_ADDR bda)
 350 {
 351     tBTA_GATTC_SERV *p_srcb = &bta_gattc_cb.known_server[0];
 352     UINT8   i;
 353
 354     for (i = 0; i < BTA_GATTC_KNOWN_SR_MAX; i ++, p_srcb ++)
 355     {
 356         if (bdcmp(p_srcb->server_bda, bda) == 0)
 357             return p_srcb;
 358     }
 359     return NULL;
 360 }
 361 /*******************************************************************************
 362 **
 363 ** Function         bta_gattc_find_scb_by_cid
 364 **
 365 ** Description      find server control block by connection ID
 366 **
 367 ** Returns          pointer to the server cache.
 368 **
 369 *******************************************************************************/
 370 tBTA_GATTC_SERV * bta_gattc_find_scb_by_cid (UINT16 conn_id)
 371 {
 372     tBTA_GATTC_CLCB *p_clcb = bta_gattc_find_clcb_by_conn_id(conn_id);
 373
 374     if (p_clcb)
 375         return p_clcb->p_srcb;
 376     else
 377         return NULL;
 378 }
 379 /*******************************************************************************
 380 **
 381 ** Function         bta_gattc_srcb_alloc
 382 **
 383 ** Description      allocate server cache control block
 384 **
 385 ** Returns          pointer to the server cache.
 386 **
 387 *******************************************************************************/
 388 tBTA_GATTC_SERV * bta_gattc_srcb_alloc(BD_ADDR bda)
 389 {
 390     tBTA_GATTC_SERV *p_tcb = &bta_gattc_cb.known_server[0],
 391                              *p_recycle = NULL;
 392     BOOLEAN         found = FALSE;
 393     UINT8           i;
 394
 395     for (i = 0; i < BTA_GATTC_KNOWN_SR_MAX; i ++, p_tcb ++)
 396     {
 397         if (!p_tcb->in_use)
 398         {
 399             found = TRUE;
 400             break;
 401         }
 402         else if (!p_tcb->connected)
 403         {
 404             p_recycle = p_tcb;
 405         }
 406     }
 407
 408     /* if not found, try to recycle one known device */
 409     if (!found && !p_recycle)
 410         p_tcb = NULL;
 411     else if (!found && p_recycle)
 412         p_tcb = p_recycle;
 413
 414     if (p_tcb != NULL)
 415     {
 416         while (!GKI_queue_is_empty(&p_tcb->cache_buffer))
 417             GKI_freebuf (GKI_dequeue (&p_tcb->cache_buffer));
 418
 419         utl_freebuf((void **)&p_tcb->p_srvc_list);
 420         memset(p_tcb, 0 , sizeof(tBTA_GATTC_SERV));
 421
 422         p_tcb->in_use = TRUE;
 423         bdcpy(p_tcb->server_bda, bda);
 424     }
 425     return p_tcb;
 426 }
 427 /*******************************************************************************
 428 **
 429 ** Function         bta_gattc_enqueue
 430 **
 431 ** Description      enqueue a client request in clcb.
 432 **
 433 ** Returns          success or failure.
 434 **
 435 *******************************************************************************/
 436 BOOLEAN bta_gattc_enqueue(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data)
 437 {
 438
 439  if (p_clcb->p_q_cmd == NULL)
 440  {
 441      p_clcb->p_q_cmd = p_data;
 442  }
 443  else
 444  {
 445      APPL_TRACE_ERROR("already has a pending command!!");
 446      /* skip the callback now. ----- need to send callback ? */
 447  }
 448  return (p_clcb->p_q_cmd != NULL) ? TRUE : FALSE;
 449
 450 }
 451
 452 /*******************************************************************************
 453 **
 454 ** Function         bta_gattc_pack_attr_uuid
 455 **
 456 ** Description      pack UUID into a stream.
 457 **
 458 ** Returns
 459 **
 460 *******************************************************************************/
 461 void bta_gattc_pack_attr_uuid(tBTA_GATTC_CACHE_ATTR   *p_attr, tBT_UUID *p_uuid)
 462 {
 463     UINT8 *pp = (UINT8 *)p_attr->p_uuid;
 464
 465     memset(p_uuid, 0, sizeof(tBT_UUID));
 466
 467     p_uuid->len = p_attr->uuid_len;
 468
 469     if (p_attr->uuid_len == LEN_UUID_16)
 470     {
 471         STREAM_TO_UINT16(p_uuid->uu.uuid16, pp);
 472     }
 473     else
 474     {
 475         memcpy(p_uuid->uu.uuid128, pp, LEN_UUID_128);
 476     }
 477
 478     return;
 479 }
 480 /*******************************************************************************
 481 **
 482 ** Function         bta_gattc_cpygattid
 483 **
 484 ** Description      copy two tBTA_GATT_ID value
 485 **
 486 ** Returns
 487 **
 488 *******************************************************************************/
 489 void bta_gattc_cpygattid(tBTA_GATT_ID *p_des, tBTA_GATT_ID *p_src)
 490 {
 491     memset ((void *)p_des, 0, sizeof(tBTA_GATT_ID));
 492
 493     p_des->inst_id = p_src->inst_id;
 494
 495     p_des->uuid.len = p_src->uuid.len;
 496
 497     if (p_des->uuid.len == LEN_UUID_16)
 498     {
 499         p_des->uuid.uu.uuid16 = p_src->uuid.uu.uuid16;
 500     }
 501     else if (p_des->uuid.len == LEN_UUID_128)
 502     {
 503         memcpy(p_des->uuid.uu.uuid128, p_src->uuid.uu.uuid128, LEN_UUID_128);
 504     }
 505 }
 506 /*******************************************************************************
 507 **
 508 ** Function         bta_gattc_gattid_compare
 509 **
 510 ** Description      compare two tBTA_GATT_ID type of pointer
 511 **
 512 ** Returns
 513 **
 514 *******************************************************************************/
 515 BOOLEAN bta_gattc_gattid_compare(tBTA_GATT_ID *p_src, tBTA_GATT_ID *p_tar)
 516 {
 517     if (p_src->inst_id == p_tar->inst_id &&
 518         bta_gattc_uuid_compare (&p_src->uuid, &p_tar->uuid, TRUE ))
 519         return TRUE;
 520     else
 521         return FALSE;
 522
 523 }
 524 /*******************************************************************************
 525 **
 526 ** Function         bta_gattc_srvcid_compare
 527 **
 528 ** Description      compare two tBTA_GATT_SRVC_ID type of pointer
 529 **
 530 ** Returns
 531 **
 532 *******************************************************************************/
 533 BOOLEAN bta_gattc_srvcid_compare(tBTA_GATT_SRVC_ID *p_src, tBTA_GATT_SRVC_ID *p_tar)
 534 {
 535     if (p_src->is_primary == p_tar->is_primary &&
 536         bta_gattc_gattid_compare (&p_src->id, &p_tar->id))
 537         return TRUE;
 538     else
 539         return FALSE;
 540 }
 541 /*******************************************************************************
 542 **
 543 ** Function         bta_gattc_charid_compare
 544 **
 545 ** Description      compare two tBTA_GATTC_CHAR_ID type of pointer
 546 **
 547 ** Returns
 548 **
 549 *******************************************************************************/
 550 BOOLEAN bta_gattc_charid_compare(tBTA_GATTC_CHAR_ID *p_src, tBTA_GATTC_CHAR_ID *p_tar)
 551 {
 552     if (bta_gattc_gattid_compare (&p_src->char_id, &p_tar->char_id) &&
 553         bta_gattc_srvcid_compare (&p_src->srvc_id, &p_tar->srvc_id))
 554         return TRUE;
 555     else
 556         return FALSE;
 557 }
 558
 559 /*******************************************************************************
 560 **
 561 ** Function         bta_gattc_check_notif_registry
 562 **
 563 ** Description      check if the service notificaition has been registered.
 564 **
 565 ** Returns
 566 **
 567 *******************************************************************************/
 568 BOOLEAN bta_gattc_check_notif_registry(tBTA_GATTC_RCB  *p_clreg, tBTA_GATTC_SERV *p_srcb,
 569                                        tBTA_GATTC_NOTIFY  *p_notify)
 570 {
 571     UINT8           i;
 572
 573     for (i = 0 ; i < BTA_GATTC_NOTIF_REG_MAX; i ++)
 574     {
 575         if (p_clreg->notif_reg[i].in_use &&
 576             bdcmp(p_clreg->notif_reg[i].remote_bda, p_srcb->server_bda) == 0 &&
 577             bta_gattc_charid_compare (&p_clreg->notif_reg[i].char_id, &p_notify->char_id))
 578         {
 579             APPL_TRACE_DEBUG("Notification registered!");
 580             return TRUE;
 581         }
 582     }
 583     return FALSE;
 584
 585 }
 586 /*******************************************************************************
 587 **
 588 ** Function         bta_gattc_clear_notif_registration
 589 **
 590 ** Description      clear up the notification registration information by BD_ADDR.
 591 **
 592 ** Returns          None.
 593 **
 594 *******************************************************************************/
 595 void bta_gattc_clear_notif_registration(UINT16 conn_id)
 596 {
 597     BD_ADDR             remote_bda;
 598     tBTA_GATTC_IF       gatt_if;
 599     tBTA_GATTC_RCB      *p_clrcb ;
 600     UINT8       i;
 601     tGATT_TRANSPORT     transport;
 602
 603     if (GATT_GetConnectionInfor(conn_id, &gatt_if, remote_bda, &transport))
 604     {
 605         if ((p_clrcb = bta_gattc_cl_get_regcb(gatt_if)) != NULL)
 606         {
 607             for (i = 0 ; i < BTA_GATTC_NOTIF_REG_MAX; i ++)
 608             {
 609                 if (p_clrcb->notif_reg[i].in_use &&
 610                     !bdcmp(p_clrcb->notif_reg[i].remote_bda, remote_bda))
 611                     memset(&p_clrcb->notif_reg[i], 0, sizeof(tBTA_GATTC_NOTIF_REG));
 612             }
 613         }
 614     }
 615     else
 616     {
 617         APPL_TRACE_ERROR("can not clear indication/notif registration for unknown app");
 618     }
 619     return;
 620 }
 621
 622 /*******************************************************************************
 623 **
 624 ** Function         bta_gattc_pack_cb_data
 625 **
 626 ** Description      pack the data from read response into callback data structure.
 627 **
 628 ** Returns
 629 **
 630 *******************************************************************************/
 631 tBTA_GATT_STATUS bta_gattc_pack_read_cb_data(tBTA_GATTC_SERV *p_srcb,
 632                                              tBT_UUID *p_descr_uuid,
 633                                              tGATT_VALUE *p_attr,
 634                                              tBTA_GATT_READ_VAL *p_value)
 635 {
 636     UINT8                   i = 0, *pp = p_attr->value;
 637     tBT_UUID                uuid = {LEN_UUID_16, {GATT_UUID_CHAR_AGG_FORMAT}};
 638     UINT16                  handle;
 639     tBTA_GATT_STATUS        status = BTA_GATT_OK;
 640
 641     /* GATT_UUID_CHAR_AGG_FORMAT */
 642     if (bta_gattc_uuid_compare (&uuid, p_descr_uuid, TRUE))
 643     {
 644         while (p_attr->len >= 2 && i < BTA_GATTC_MULTI_MAX)
 645         {
 646             STREAM_TO_UINT16(handle, pp);
 647
 648             if (bta_gattc_handle2id(p_srcb,
 649                                     handle,
 650                                     &p_value->aggre_value.pre_format[i].char_id.srvc_id,
 651                                     &p_value->aggre_value.pre_format[i].char_id.char_id,
 652                                     &p_value->aggre_value.pre_format[i].descr_id) == FALSE)
 653             {
 654                 status = BTA_GATT_INTERNAL_ERROR;
 655                 APPL_TRACE_ERROR("can not map to GATT ID. handle = 0x%04x", handle);
 656                 break;
 657             }
 658             i ++;
 659             p_attr->len -= 2;
 660         }
 661         p_value->aggre_value.num_pres_fmt = i;
 662     }
 663     else
 664     {
 665         /* all others, take as raw format */
 666         p_value->unformat.len = p_attr->len;
 667         p_value->unformat.p_value = p_attr->value;
 668     }
 669     return status;
 670 }
 671 /*******************************************************************************
 672 **
 673 ** Function         bta_gattc_mark_bg_conn
 674 **
 675 ** Description      mark background connection status when a bg connection is initiated
 676 **                  or terminated.
 677 **
 678 ** Returns          TRUE if success; FALSE otherwise.
 679 **
 680 *******************************************************************************/
 681 BOOLEAN bta_gattc_mark_bg_conn (tBTA_GATTC_IF client_if,  BD_ADDR_PTR remote_bda_ptr,
 682                                 BOOLEAN add, BOOLEAN is_listen)
 683 {
 684     tBTA_GATTC_BG_TCK   *p_bg_tck = &bta_gattc_cb.bg_track[0];
 685     UINT8   i = 0;
 686     tBTA_GATTC_CIF_MASK  *p_cif_mask;
 687
 688     for (i = 0; i < BTA_GATTC_KNOWN_SR_MAX; i ++, p_bg_tck ++)
 689     {
 690         if (p_bg_tck->in_use &&
 691             ((remote_bda_ptr != NULL && bdcmp(p_bg_tck->remote_bda, remote_bda_ptr) == 0) ||
 692             (remote_bda_ptr == NULL && bdcmp(p_bg_tck->remote_bda, dummy_bda) == 0)))
 693         {
 694              p_cif_mask = is_listen ? &p_bg_tck->cif_adv_mask : &p_bg_tck->cif_mask;
 695
 696             if (add)
 697                 /* mask on the cif bit */
 698                 *p_cif_mask |= (1 <<(client_if - 1));
 699             else
 700             {
 701                 if (client_if != 0)
 702                     *p_cif_mask &= (~(1 <<(client_if - 1)));
 703                 else
 704                     *p_cif_mask = 0;
 705             }
 706             /* no BG connection for this device, make it available */
 707             if (p_bg_tck->cif_mask == 0 && p_bg_tck->cif_adv_mask == 0)
 708             {
 709                 memset(p_bg_tck, 0, sizeof(tBTA_GATTC_BG_TCK));
 710             }
 711             return TRUE;
 712         }
 713     }
 714     if (!add)
 715     {
 716         if (remote_bda_ptr)
 717         {
 718             bdstr_t bdstr = {0};
 719             APPL_TRACE_ERROR("%s unable to find the bg connection mask for: %s", __func__,
 720                 bdaddr_to_string((bt_bdaddr_t *)remote_bda_ptr, bdstr, sizeof(bdstr)));
 721         }
 722         return FALSE;
 723     }
 724     else /* adding a new device mask */
 725     {
 726         for (i = 0, p_bg_tck = &bta_gattc_cb.bg_track[0];
 727              i < BTA_GATTC_KNOWN_SR_MAX; i ++, p_bg_tck ++)
 728         {
 729             if (!p_bg_tck->in_use)
 730             {
 731                 p_bg_tck->in_use = TRUE;
 732                 if (remote_bda_ptr)
 733                     bdcpy(p_bg_tck->remote_bda, remote_bda_ptr);
 734                 else
 735                     bdcpy(p_bg_tck->remote_bda, dummy_bda);
 736
 737                 p_cif_mask = is_listen ? &p_bg_tck->cif_adv_mask : &p_bg_tck->cif_mask;
 738
 739                 *p_cif_mask = (1 <<(client_if - 1));
 740                 return TRUE;
 741             }
 742         }
 743         APPL_TRACE_ERROR("no available space to mark the bg connection status");
 744         return FALSE;
 745     }
 746 }
 747 /*******************************************************************************
 748 **
 749 ** Function         bta_gattc_check_bg_conn
 750 **
 751 ** Description      check if this is a background connection background connection.
 752 **
 753 ** Returns          TRUE if success; FALSE otherwise.
 754 **
 755 *******************************************************************************/
 756 BOOLEAN bta_gattc_check_bg_conn (tBTA_GATTC_IF client_if,  BD_ADDR remote_bda, UINT8 role)
 757 {
 758     tBTA_GATTC_BG_TCK   *p_bg_tck = &bta_gattc_cb.bg_track[0];
 759     UINT8       i = 0;
 760     BOOLEAN     is_bg_conn = FALSE;
 761
 762     for (i = 0; i < BTA_GATTC_KNOWN_SR_MAX && !is_bg_conn; i ++, p_bg_tck ++)
 763     {
 764         if (p_bg_tck->in_use &&
 765             (bdcmp(p_bg_tck->remote_bda, remote_bda) == 0 ||
 766              bdcmp(p_bg_tck->remote_bda, dummy_bda) == 0))
 767         {
 768             if (((p_bg_tck->cif_mask &(1 <<(client_if - 1))) != 0) &&
 769                 role == HCI_ROLE_MASTER)
 770                 is_bg_conn = TRUE;
 771
 772             if (((p_bg_tck->cif_adv_mask &(1 <<(client_if - 1))) != 0) &&
 773                 role == HCI_ROLE_SLAVE)
 774                 is_bg_conn = TRUE;
 775         }
 776     }
 777     return is_bg_conn;
 778 }
 779 /*******************************************************************************
 780 **
 781 ** Function         bta_gattc_send_open_cback
 782 **
 783 ** Description      send open callback
 784 **
 785 ** Returns
 786 **
 787 *******************************************************************************/
 788 void bta_gattc_send_open_cback( tBTA_GATTC_RCB *p_clreg, tBTA_GATT_STATUS status,
 789                                 BD_ADDR remote_bda, UINT16 conn_id,
 790                                 tBTA_TRANSPORT transport, UINT16 mtu)
 791 {
 792     tBTA_GATTC      cb_data;
 793
 794     if (p_clreg->p_cback)
 795     {
 796         memset(&cb_data, 0, sizeof(tBTA_GATTC));
 797
 798         cb_data.open.status = status;
 799         cb_data.open.client_if = p_clreg->client_if;
 800         cb_data.open.conn_id = conn_id;
 801         cb_data.open.mtu = mtu;
 802         cb_data.open.transport = transport;
 803         bdcpy(cb_data.open.remote_bda, remote_bda);
 804
 805         (*p_clreg->p_cback)(BTA_GATTC_OPEN_EVT, &cb_data);
 806     }
 807 }
 808 /*******************************************************************************
 809 **
 810 ** Function         bta_gattc_conn_alloc
 811 **
 812 ** Description      allocate connection tracking spot
 813 **
 814 ** Returns          pointer to the clcb
 815 **
 816 *******************************************************************************/
 817 tBTA_GATTC_CONN * bta_gattc_conn_alloc(BD_ADDR remote_bda)
 818 {
 819     UINT8               i_conn = 0;
 820     tBTA_GATTC_CONN     *p_conn = &bta_gattc_cb.conn_track[0];
 821
 822     for (i_conn = 0; i_conn < BTA_GATTC_CONN_MAX; i_conn++, p_conn ++)
 823     {
 824         if (!p_conn->in_use)
 825         {
 826 #if BTA_GATT_DEBUG == TRUE
 827             APPL_TRACE_DEBUG("bta_gattc_conn_alloc: found conn_track[%d] available",i_conn);
 828 #endif
 829             p_conn->in_use          = TRUE;
 830             bdcpy(p_conn->remote_bda, remote_bda);
 831             return p_conn;
 832         }
 833     }
 834     return NULL;
 835 }
 836
 837 /*******************************************************************************
 838 **
 839 ** Function         bta_gattc_conn_find
 840 **
 841 ** Description      allocate connection tracking spot
 842 **
 843 ** Returns          pointer to the clcb
 844 **
 845 *******************************************************************************/
 846 tBTA_GATTC_CONN * bta_gattc_conn_find(BD_ADDR remote_bda)
 847 {
 848     UINT8               i_conn = 0;
 849     tBTA_GATTC_CONN     *p_conn = &bta_gattc_cb.conn_track[0];
 850
 851     for (i_conn = 0; i_conn < BTA_GATTC_CONN_MAX; i_conn++, p_conn ++)
 852     {
 853         if (p_conn->in_use && bdcmp(remote_bda, p_conn->remote_bda) == 0)
 854         {
 855 #if BTA_GATT_DEBUG == TRUE
 856             APPL_TRACE_DEBUG("bta_gattc_conn_find: found conn_track[%d] matched",i_conn);
 857 #endif
 858             return p_conn;
 859         }
 860     }
 861     return NULL;
 862 }
 863
 864 /*******************************************************************************
 865 **
 866 ** Function         bta_gattc_conn_find_alloc
 867 **
 868 ** Description      find or allocate connection tracking spot
 869 **
 870 ** Returns          pointer to the clcb
 871 **
 872 *******************************************************************************/
 873 tBTA_GATTC_CONN * bta_gattc_conn_find_alloc(BD_ADDR remote_bda)
 874 {
 875     tBTA_GATTC_CONN     *p_conn = bta_gattc_conn_find (remote_bda);
 876
 877     if (p_conn == NULL)
 878     {
 879         p_conn = bta_gattc_conn_alloc(remote_bda);
 880     }
 881     return p_conn;
 882 }
 883
 884 /*******************************************************************************
 885 **
 886 ** Function         bta_gattc_conn_dealloc
 887 **
 888 ** Description      de-allocate connection tracking spot
 889 **
 890 ** Returns          pointer to the clcb
 891 **
 892 *******************************************************************************/
 893 BOOLEAN bta_gattc_conn_dealloc(BD_ADDR remote_bda)
 894 {
 895     tBTA_GATTC_CONN     *p_conn = bta_gattc_conn_find (remote_bda);
 896
 897     if (p_conn != NULL)
 898     {
 899         p_conn->in_use = FALSE;
 900         memset(p_conn->remote_bda, 0, BD_ADDR_LEN);
 901         return TRUE;
 902     }
 903     return FALSE;
 904 }
 905
 906 /*******************************************************************************
 907 **
 908 ** Function         bta_gattc_find_int_conn_clcb
 909 **
 910 ** Description      try to locate a clcb when an internal connecion event arrives.
 911 **
 912 ** Returns          pointer to the clcb
 913 **
 914 *******************************************************************************/
 915 tBTA_GATTC_CLCB * bta_gattc_find_int_conn_clcb(tBTA_GATTC_DATA *p_msg)
 916 {
 917     tBTA_GATTC_CLCB *p_clcb = NULL;
 918
 919     if (p_msg->int_conn.role == HCI_ROLE_SLAVE)
 920         bta_gattc_conn_find_alloc(p_msg->int_conn.remote_bda);
 921
 922     /* try to locate a logic channel */
 923     if ((p_clcb = bta_gattc_find_clcb_by_cif(p_msg->int_conn.client_if,
 924                                              p_msg->int_conn.remote_bda,
 925                                              p_msg->int_conn.transport)) == NULL)
 926     {
 927         /* for a background connection or listening connection */
 928         if (/*p_msg->int_conn.role == HCI_ROLE_SLAVE ||  */
 929             bta_gattc_check_bg_conn(p_msg->int_conn.client_if,
 930                                     p_msg->int_conn.remote_bda,
 931                                     p_msg->int_conn.role))
 932         {
 933             /* allocate a new channel */
 934             p_clcb = bta_gattc_clcb_alloc(p_msg->int_conn.client_if,
 935                                           p_msg->int_conn.remote_bda,
 936                                           p_msg->int_conn.transport);
 937         }
 938     }
 939     return p_clcb;
 940 }
 941
 942 /*******************************************************************************
 943 **
 944 ** Function         bta_gattc_find_int_disconn_clcb
 945 **
 946 ** Description      try to locate a clcb when an internal disconnect callback arrives.
 947 **
 948 ** Returns          pointer to the clcb
 949 **
 950 *******************************************************************************/
 951 tBTA_GATTC_CLCB * bta_gattc_find_int_disconn_clcb(tBTA_GATTC_DATA *p_msg)
 952 {
 953     tBTA_GATTC_CLCB         *p_clcb = NULL;
 954
 955     bta_gattc_conn_dealloc(p_msg->int_conn.remote_bda);
 956     if ((p_clcb = bta_gattc_find_clcb_by_conn_id(p_msg->int_conn.hdr.layer_specific)) == NULL)
 957     {
 958         /* connection attempt failed, send connection callback event */
 959         p_clcb = bta_gattc_find_clcb_by_cif(p_msg->int_conn.client_if,
 960                                             p_msg->int_conn.remote_bda,
 961                                             p_msg->int_conn.transport);
 962     }
 963     if (p_clcb == NULL)
 964     {
 965         APPL_TRACE_DEBUG(" disconnection ID: [%d] not used by BTA",
 966             p_msg->int_conn.hdr.layer_specific);
 967     }
 968     return p_clcb;
 969 }
 970
 971 #endif /* BTA_GATT_INCLUDED */