bta/hl/bta_hl_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 implements utility functions for the HeaLth device profile
  22  *  (HL).
  23  *
  24  ******************************************************************************/
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28
  29 #include "bt_target.h"
  30 #if defined(HL_INCLUDED) && (HL_INCLUDED == TRUE)
  31
  32
  33 #include "bt_common.h"
  34 #include "utl.h"
  35 #include "bta_hl_int.h"
  36 #include "bta_hl_co.h"
  37 #include "mca_defs.h"
  38 #include "mca_api.h"
  39
  40
  41 /*******************************************************************************
  42 **
  43 ** Function      bta_hl_set_ctrl_psm_for_dch
  44 **
  45 ** Description    This function set the control PSM for the DCH setup
  46 **
  47 ** Returns     BOOLEAN - TRUE - control PSM setting is successful
  48 *******************************************************************************/
  49 BOOLEAN bta_hl_set_ctrl_psm_for_dch(UINT8 app_idx, UINT8 mcl_idx,
  50                                     UINT8 mdl_idx, UINT16 ctrl_psm)
  51 {
  52     tBTA_HL_MCL_CB *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
  53     BOOLEAN success = TRUE, update_ctrl_psm = FALSE;
  54     UNUSED(mdl_idx);
  55
  56     if (p_mcb->sdp.num_recs)
  57     {
  58         if (p_mcb->ctrl_psm != ctrl_psm)
  59         {
  60             /* can not use a different ctrl PSM than the current one*/
  61             success = FALSE;
  62         }
  63     }
  64     else
  65     {
  66         /* No SDP info control i.e. channel was opened by the peer */
  67         update_ctrl_psm = TRUE;
  68     }
  69
  70     if (success && update_ctrl_psm)
  71     {
  72         p_mcb->ctrl_psm = ctrl_psm;
  73     }
  74
  75
  76 #if BTA_HL_DEBUG == TRUE
  77     if (!success)
  78     {
  79         APPL_TRACE_DEBUG("bta_hl_set_ctrl_psm_for_dch num_recs=%d success=%d update_ctrl_psm=%d ctrl_psm=0x%x ",
  80                           p_mcb->sdp.num_recs, success, update_ctrl_psm, ctrl_psm );
  81     }
  82 #endif
  83
  84     return success;
  85 }
  86
  87
  88 /*******************************************************************************
  89 **
  90 ** Function      bta_hl_find_sdp_idx_using_ctrl_psm
  91 **
  92 ** Description
  93 **
  94 ** Returns      TRUE if found
  95 **
  96 *******************************************************************************/
  97 BOOLEAN bta_hl_find_sdp_idx_using_ctrl_psm(tBTA_HL_SDP *p_sdp,
  98                                            UINT16 ctrl_psm,
  99                                            UINT8 *p_sdp_idx)
 100 {
 101     BOOLEAN found=FALSE;
 102     tBTA_HL_SDP_REC     *p_rec;
 103     UINT8 i;
 104
 105     if (ctrl_psm != 0)
 106     {
 107         for (i=0; i<p_sdp->num_recs; i++)
 108         {
 109             p_rec = &p_sdp->sdp_rec[i];
 110             if (p_rec->ctrl_psm == ctrl_psm)
 111             {
 112                 *p_sdp_idx = i;
 113                 found = TRUE;
 114                 break;
 115             }
 116         }
 117     }
 118     else
 119     {
 120         *p_sdp_idx = 0;
 121         found = TRUE;
 122     }
 123
 124 #if BTA_HL_DEBUG == TRUE
 125     if (!found)
 126     {
 127         APPL_TRACE_DEBUG("bta_hl_find_sdp_idx_using_ctrl_psm found=%d sdp_idx=%d ctrl_psm=0x%x ",
 128                           found, *p_sdp_idx, ctrl_psm );
 129     }
 130 #endif
 131     return found;
 132 }
 133
 134 /*******************************************************************************
 135 **
 136 ** Function      bta_hl_set_user_tx_buf_size
 137 **
 138 ** Description  This function sets the user tx buffer size
 139 **
 140 ** Returns      UINT16 buf_size
 141 **
 142 *******************************************************************************/
 143
 144 UINT16 bta_hl_set_user_tx_buf_size(UINT16 max_tx_size)
 145 {
 146     if (max_tx_size > BT_DEFAULT_BUFFER_SIZE)
 147         return BTA_HL_LRG_DATA_BUF_SIZE;
 148     return L2CAP_INVALID_ERM_BUF_SIZE;
 149 }
 150
 151 /*******************************************************************************
 152 **
 153 ** Function      bta_hl_set_user_rx_buf_size
 154 **
 155 ** Description  This function sets the user rx buffer size
 156 **
 157 ** Returns      UINT16 buf_size
 158 **
 159 *******************************************************************************/
 160
 161 UINT16 bta_hl_set_user_rx_buf_size(UINT16 mtu)
 162 {
 163     if (mtu > BT_DEFAULT_BUFFER_SIZE)
 164         return BTA_HL_LRG_DATA_BUF_SIZE;
 165     return L2CAP_INVALID_ERM_BUF_SIZE;
 166 }
 167
 168
 169
 170 /*******************************************************************************
 171 **
 172 ** Function      bta_hl_set_tx_win_size
 173 **
 174 ** Description  This function sets the tx window size
 175 **
 176 ** Returns      UINT8 tx_win_size
 177 **
 178 *******************************************************************************/
 179 UINT8 bta_hl_set_tx_win_size(UINT16 mtu, UINT16 mps)
 180 {
 181     UINT8 tx_win_size;
 182
 183     if (mtu <= mps)
 184     {
 185         tx_win_size =1;
 186     }
 187     else
 188     {
 189         if (mps > 0)
 190         {
 191             tx_win_size = (mtu/mps)+1;
 192         }
 193         else
 194         {
 195             APPL_TRACE_ERROR("The MPS is zero");
 196             tx_win_size = 10;
 197         }
 198     }
 199
 200 #if BTA_HL_DEBUG == TRUE
 201     APPL_TRACE_DEBUG("bta_hl_set_tx_win_size win_size=%d mtu=%d mps=%d",
 202                       tx_win_size, mtu, mps);
 203 #endif
 204     return tx_win_size;
 205 }
 206
 207 /*******************************************************************************
 208 **
 209 ** Function      bta_hl_set_mps
 210 **
 211 ** Description  This function sets the MPS
 212 **
 213 ** Returns      UINT16 MPS
 214 **
 215 *******************************************************************************/
 216 UINT16 bta_hl_set_mps(UINT16 mtu)
 217 {
 218     UINT16 mps;
 219     if (mtu > BTA_HL_L2C_MPS)
 220     {
 221         mps = BTA_HL_L2C_MPS;
 222     }
 223     else
 224     {
 225         mps = mtu;
 226     }
 227 #if BTA_HL_DEBUG == TRUE
 228     APPL_TRACE_DEBUG("bta_hl_set_mps mps=%d mtu=%d",
 229                       mps, mtu);
 230 #endif
 231     return mps;
 232 }
 233
 234
 235 /*******************************************************************************
 236 **
 237 ** Function      bta_hl_clean_mdl_cb
 238 **
 239 ** Description  This function clean up the specified MDL control block
 240 **
 241 ** Returns      void
 242 **
 243 *******************************************************************************/
 244 void bta_hl_clean_mdl_cb(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx)
 245 {
 246     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
 247 #if BTA_HL_DEBUG == TRUE
 248     APPL_TRACE_DEBUG("bta_hl_clean_mdl_cb app_idx=%d mcl_idx=%d mdl_idx=%d",
 249                       app_idx, mcl_idx, mdl_idx);
 250 #endif
 251     osi_free_and_reset((void **)&p_dcb->p_tx_pkt);
 252     osi_free_and_reset((void **)&p_dcb->p_rx_pkt);
 253     osi_free_and_reset((void **)&p_dcb->p_echo_tx_pkt);
 254     osi_free_and_reset((void **)&p_dcb->p_echo_rx_pkt);
 255
 256     memset((void *)p_dcb, 0 , sizeof(tBTA_HL_MDL_CB));
 257 }
 258
 259
 260 /*******************************************************************************
 261 **
 262 ** Function      bta_hl_get_buf
 263 **
 264 ** Description  This function allocate a buffer based on the specified data size
 265 **
 266 ** Returns      BT_HDR *.
 267 **
 268 *******************************************************************************/
 269 BT_HDR * bta_hl_get_buf(UINT16 data_size, BOOLEAN fcs_use)
 270 {
 271     size_t size = data_size + L2CAP_MIN_OFFSET + BT_HDR_SIZE + L2CAP_FCS_LEN
 272                                                    + L2CAP_EXT_CONTROL_OVERHEAD;
 273
 274     if (fcs_use)
 275         size += L2CAP_FCS_LEN;
 276
 277     BT_HDR *p_new = (BT_HDR *)osi_malloc(size);
 278     p_new->len = data_size;
 279     p_new->offset = L2CAP_MIN_OFFSET;
 280
 281     return p_new;
 282 }
 283
 284 /*******************************************************************************
 285 **
 286 ** Function      bta_hl_find_service_in_db
 287 **
 288 ** Description  This function check the specified service class(es) can be find in
 289 **              the received SDP database
 290 **
 291 ** Returns      BOOLEAN TRUE - found
 292 **                      FALSE - not found
 293 **
 294 *******************************************************************************/
 295 BOOLEAN bta_hl_find_service_in_db( UINT8 app_idx, UINT8 mcl_idx,
 296                                    UINT16 service_uuid,
 297                                    tSDP_DISC_REC **pp_rec )
 298 {
 299     tBTA_HL_MCL_CB          *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
 300     BOOLEAN found = TRUE;
 301
 302     switch (service_uuid)
 303     {
 304         case UUID_SERVCLASS_HDP_SINK:
 305         case UUID_SERVCLASS_HDP_SOURCE:
 306             if ((*pp_rec = SDP_FindServiceInDb(p_mcb->p_db, service_uuid,
 307                                                *pp_rec)) == NULL)
 308             {
 309                 found = FALSE;
 310             }
 311             break;
 312         default:
 313             if (((*pp_rec = bta_hl_find_sink_or_src_srv_class_in_db(p_mcb->p_db,
 314                                                                     *pp_rec)) == NULL))
 315             {
 316                 found = FALSE;
 317             }
 318             break;
 319     }
 320     return found;
 321 }
 322
 323 /*******************************************************************************
 324 **
 325 ** Function      bta_hl_get_service_uuids
 326 **
 327 **
 328 ** Description  This function finds the service class(es) for both CCH and DCH oeprations
 329 **
 330 ** Returns      UINT16 - service_id
 331 **                       if service_uuid = 0xFFFF then it means service uuid
 332 **                       can be either Sink or Source
 333 **
 334 *******************************************************************************/
 335 UINT16 bta_hl_get_service_uuids(UINT8 sdp_oper, UINT8 app_idx, UINT8 mcl_idx,
 336                                 UINT8 mdl_idx )
 337 {
 338     tBTA_HL_MDL_CB          *p_dcb;
 339     UINT16                  service_uuid = 0xFFFF; /* both Sink and Source */
 340
 341     switch (sdp_oper)
 342     {
 343
 344         case BTA_HL_SDP_OP_DCH_OPEN_INIT:
 345         case BTA_HL_SDP_OP_DCH_RECONNECT_INIT:
 346             p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
 347             if (p_dcb->local_mdep_id != BTA_HL_ECHO_TEST_MDEP_ID)
 348             {
 349                 if (p_dcb->peer_mdep_role == BTA_HL_MDEP_ROLE_SINK)
 350                 {
 351                     service_uuid = UUID_SERVCLASS_HDP_SINK;
 352                 }
 353                 else
 354                 {
 355                     service_uuid = UUID_SERVCLASS_HDP_SOURCE;
 356                 }
 357             }
 358             break;
 359         case BTA_HL_SDP_OP_CCH_INIT:
 360         default:
 361             /* use default that is both Sink and Source */
 362             break;
 363     }
 364 #if BTA_HL_DEBUG == TRUE
 365     APPL_TRACE_DEBUG("bta_hl_get_service_uuids service_uuid=0x%x",service_uuid );
 366 #endif
 367     return service_uuid;
 368 }
 369
 370 /*******************************************************************************
 371 **
 372 ** Function      bta_hl_find_echo_cfg_rsp
 373 **
 374 **
 375 ** Description  This function finds the configuration response for the echo test
 376 **
 377 ** Returns      BOOLEAN - TRUE found
 378 **                        FALSE not found
 379 **
 380 *******************************************************************************/
 381 BOOLEAN bta_hl_find_echo_cfg_rsp(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdep_idx, UINT8 cfg,
 382                                  UINT8 *p_cfg_rsp)
 383 {
 384     tBTA_HL_APP_CB      *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
 385     tBTA_HL_MDEP        *p_mdep= &p_acb->sup_feature.mdep[mdep_idx];
 386     BOOLEAN             status =TRUE;
 387
 388     if (p_mdep->mdep_id == BTA_HL_ECHO_TEST_MDEP_ID)
 389     {
 390         if ((cfg == BTA_HL_DCH_CFG_RELIABLE) || (cfg == BTA_HL_DCH_CFG_STREAMING))
 391         {
 392             *p_cfg_rsp = cfg;
 393         }
 394         else if (cfg == BTA_HL_DCH_CFG_NO_PREF )
 395         {
 396             *p_cfg_rsp = BTA_HL_DEFAULT_ECHO_TEST_SRC_DCH_CFG;
 397         }
 398         else
 399         {
 400             status = FALSE;
 401             APPL_TRACE_ERROR("Inavlid echo cfg value");
 402         }
 403         return status;
 404     }
 405
 406 #if BTA_HL_DEBUG == TRUE
 407     if (!status)
 408     {
 409         APPL_TRACE_DEBUG("bta_hl_find_echo_cfg_rsp status=failed app_idx=%d mcl_idx=%d mdep_idx=%d cfg=%d",
 410                           app_idx, mcl_idx, mdep_idx, cfg);
 411     }
 412 #endif
 413
 414     return status;
 415 }
 416
 417 /*******************************************************************************
 418 **
 419 ** Function      bta_hl_validate_dch_cfg
 420 **
 421 ** Description  This function validate the DCH configuration
 422 **
 423 ** Returns      BOOLEAN - TRUE cfg is valid
 424 **                        FALSE not valid
 425 **
 426 *******************************************************************************/
 427 BOOLEAN bta_hl_validate_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
 428                             UINT8 cfg)
 429 {
 430     tBTA_HL_MDL_CB      *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
 431     BOOLEAN is_valid =FALSE;
 432
 433
 434     if (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx) &&
 435         (cfg != BTA_HL_DCH_CFG_RELIABLE))
 436     {
 437         APPL_TRACE_ERROR("the first DCH should be a reliable channel");
 438         return is_valid;
 439     }
 440
 441     switch (p_dcb->local_cfg)
 442     {
 443         case BTA_HL_DCH_CFG_NO_PREF:
 444
 445             if ((cfg == BTA_HL_DCH_CFG_RELIABLE) || (cfg == BTA_HL_DCH_CFG_STREAMING))
 446             {
 447                 is_valid = TRUE;
 448             }
 449             break;
 450         case BTA_HL_DCH_CFG_RELIABLE:
 451         case BTA_HL_DCH_CFG_STREAMING:
 452             if (p_dcb->local_cfg == cfg )
 453             {
 454                 is_valid = TRUE;
 455             }
 456             break;
 457         default:
 458             break;
 459     }
 460
 461 #if BTA_HL_DEBUG == TRUE
 462     if (!is_valid)
 463     {
 464         APPL_TRACE_DEBUG("bta_hl_validate_dch_open_cfg is_valid=%d, cfg=%d", is_valid, cfg );
 465     }
 466 #endif
 467     return is_valid;
 468 }
 469
 470 /*******************************************************************************
 471 **
 472 ** Function       bta_hl_find_cch_cb_indexes
 473 **
 474 ** Description  This function finds the indexes needed for the CCH state machine
 475 **
 476 ** Returns      BOOLEAN - TRUE found
 477 **                        FALSE not found
 478 **
 479 *******************************************************************************/
 480 BOOLEAN bta_hl_find_cch_cb_indexes(tBTA_HL_DATA *p_msg,
 481                                    UINT8 *p_app_idx,
 482                                    UINT8  *p_mcl_idx)
 483 {
 484     BOOLEAN found = FALSE;
 485     tBTA_HL_MCL_CB      *p_mcb;
 486     UINT8               app_idx = 0, mcl_idx = 0;
 487
 488     switch (p_msg->hdr.event)
 489     {
 490         case BTA_HL_CCH_SDP_OK_EVT:
 491         case BTA_HL_CCH_SDP_FAIL_EVT:
 492             app_idx = p_msg->cch_sdp.app_idx;
 493             mcl_idx = p_msg->cch_sdp.mcl_idx;
 494             found = TRUE;
 495             break;
 496
 497         case BTA_HL_MCA_CONNECT_IND_EVT:
 498
 499             if (bta_hl_find_app_idx_using_handle(p_msg->mca_evt.app_handle, &app_idx))
 500             {
 501                 if (bta_hl_find_mcl_idx(app_idx, p_msg->mca_evt.mca_data.connect_ind.bd_addr, &mcl_idx))
 502                 {
 503                     /* local initiated */
 504                     found = TRUE;
 505                 }
 506                 else if (!bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx)&&
 507                          bta_hl_find_avail_mcl_idx(app_idx, &mcl_idx))
 508                 {
 509                     /* remote initiated */
 510                     p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
 511                     p_mcb->in_use = TRUE;
 512                     p_mcb->cch_oper = BTA_HL_CCH_OP_REMOTE_OPEN;
 513                     found = TRUE;
 514                 }
 515             }
 516             break;
 517
 518         case BTA_HL_MCA_DISCONNECT_IND_EVT:
 519
 520             if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx,  &mcl_idx))
 521             {
 522                 found = TRUE;
 523             }
 524             else if (bta_hl_find_app_idx_using_handle(p_msg->mca_evt.app_handle, &app_idx) &&
 525                      bta_hl_find_mcl_idx(app_idx, p_msg->mca_evt.mca_data.disconnect_ind.bd_addr, &mcl_idx))
 526             {
 527                 found = TRUE;
 528             }
 529
 530             if (found)
 531             {
 532                 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
 533                 if ((p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_CLOSE) && (p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_OPEN) )
 534                 {
 535                     p_mcb->cch_oper = BTA_HL_CCH_OP_REMOTE_CLOSE;
 536                 }
 537             }
 538             break;
 539
 540         case BTA_HL_MCA_RSP_TOUT_IND_EVT:
 541
 542             if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx,  &mcl_idx))
 543             {
 544                 found = TRUE;
 545             }
 546
 547             if (found)
 548             {
 549                 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
 550                 if ((p_mcb->cch_oper != BTA_HL_CCH_OP_REMOTE_CLOSE) && (p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_OPEN))
 551                 {
 552                     p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_CLOSE;
 553                 }
 554             }
 555             break;
 556         default:
 557             break;
 558     }
 559
 560
 561     if (found)
 562     {
 563         *p_app_idx = app_idx;
 564         *p_mcl_idx = mcl_idx;
 565     }
 566
 567 #if BTA_HL_DEBUG == TRUE
 568     if (!found)
 569     {
 570         APPL_TRACE_DEBUG("bta_hl_find_cch_cb_indexes event=%s found=%d app_idx=%d mcl_idx=%d",
 571                           bta_hl_evt_code(p_msg->hdr.event), found, app_idx, mcl_idx);
 572     }
 573 #endif
 574
 575     return found;
 576 }
 577
 578 /*******************************************************************************
 579 **
 580 ** Function       bta_hl_find_dch_cb_indexes
 581 **
 582 ** Description  This function finds the indexes needed for the DCH state machine
 583 **
 584 ** Returns      BOOLEAN - TRUE found
 585 **                        FALSE not found
 586 **
 587 *******************************************************************************/
 588 BOOLEAN bta_hl_find_dch_cb_indexes(tBTA_HL_DATA *p_msg,
 589                                    UINT8 *p_app_idx,
 590                                    UINT8 *p_mcl_idx,
 591                                    UINT8 *p_mdl_idx)
 592 {
 593     BOOLEAN         found = FALSE;
 594     tBTA_HL_MCL_CB  *p_mcb;
 595     UINT8           app_idx = 0, mcl_idx = 0, mdl_idx = 0;
 596
 597     switch (p_msg->hdr.event)
 598     {
 599         case BTA_HL_MCA_CREATE_CFM_EVT:
 600             if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
 601                 bta_hl_find_mdl_idx( app_idx,  mcl_idx,  p_msg->mca_evt.mca_data.create_cfm.mdl_id, &mdl_idx))
 602             {
 603                 found = TRUE;
 604             }
 605             break;
 606
 607         case BTA_HL_MCA_CREATE_IND_EVT:
 608         case BTA_HL_MCA_RECONNECT_IND_EVT:
 609             if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
 610                 bta_hl_find_avail_mdl_idx( app_idx,  mcl_idx, &mdl_idx))
 611             {
 612                 found = TRUE;
 613             }
 614             break;
 615
 616         case BTA_HL_MCA_OPEN_CFM_EVT:
 617             if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
 618                 bta_hl_find_mdl_idx( app_idx,  mcl_idx,  p_msg->mca_evt.mca_data.open_cfm.mdl_id, &mdl_idx))
 619             {
 620                 found = TRUE;
 621             }
 622             break;
 623
 624         case BTA_HL_MCA_OPEN_IND_EVT:
 625             if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
 626                 bta_hl_find_mdl_idx( app_idx,  mcl_idx,  p_msg->mca_evt.mca_data.open_ind.mdl_id, &mdl_idx))
 627             {
 628                 found = TRUE;
 629             }
 630             break;
 631
 632         case BTA_HL_MCA_CLOSE_CFM_EVT:
 633
 634             if (bta_hl_find_mdl_idx_using_handle((tBTA_HL_MDL_HANDLE)p_msg->mca_evt.mca_data.close_cfm.mdl,
 635                                                  &app_idx, &mcl_idx, &mdl_idx))
 636             {
 637                 found = TRUE;
 638             }
 639             break;
 640         case BTA_HL_MCA_CLOSE_IND_EVT:
 641
 642             if (bta_hl_find_mdl_idx_using_handle((tBTA_HL_MDL_HANDLE)p_msg->mca_evt.mca_data.close_ind.mdl,
 643                                                  &app_idx, &mcl_idx, &mdl_idx))
 644             {
 645                 found = TRUE;
 646             }
 647             break;
 648         case BTA_HL_API_SEND_DATA_EVT:
 649
 650             if (bta_hl_find_mdl_idx_using_handle(p_msg->api_send_data.mdl_handle,
 651                                                  &app_idx, &mcl_idx, &mdl_idx ))
 652             {
 653                 found = TRUE;
 654             }
 655
 656             break;
 657
 658         case BTA_HL_MCA_CONG_CHG_EVT:
 659
 660             if (bta_hl_find_mdl_idx_using_handle((tBTA_HL_MDL_HANDLE)p_msg->mca_evt.mca_data.cong_chg.mdl,
 661                                                  &app_idx, &mcl_idx, &mdl_idx ))
 662             {
 663                 found = TRUE;
 664             }
 665
 666             break;
 667
 668         case BTA_HL_MCA_RCV_DATA_EVT:
 669             app_idx = p_msg->mca_rcv_data_evt.app_idx;
 670             mcl_idx = p_msg->mca_rcv_data_evt.mcl_idx;
 671             mdl_idx = p_msg->mca_rcv_data_evt.mdl_idx;
 672             found = TRUE;
 673             break;
 674         case BTA_HL_DCH_RECONNECT_EVT:
 675         case BTA_HL_DCH_OPEN_EVT:
 676         case BTA_HL_DCH_ECHO_TEST_EVT:
 677         case BTA_HL_DCH_SDP_FAIL_EVT:
 678             app_idx = p_msg->dch_sdp.app_idx;
 679             mcl_idx = p_msg->dch_sdp.mcl_idx;
 680             mdl_idx = p_msg->dch_sdp.mdl_idx;
 681             found = TRUE;
 682             break;
 683         case BTA_HL_MCA_RECONNECT_CFM_EVT:
 684             if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
 685                 bta_hl_find_mdl_idx( app_idx,  mcl_idx,  p_msg->mca_evt.mca_data.reconnect_cfm.mdl_id, &mdl_idx))
 686             {
 687                 found = TRUE;
 688             }
 689             break;
 690
 691
 692         case BTA_HL_API_DCH_CREATE_RSP_EVT:
 693             if (bta_hl_find_mcl_idx_using_handle(p_msg->api_dch_create_rsp.mcl_handle, &app_idx, &mcl_idx)&&
 694                 bta_hl_find_mdl_idx( app_idx,  mcl_idx,p_msg->api_dch_create_rsp.mdl_id, &mdl_idx))
 695             {
 696                 found = TRUE;
 697             }
 698             break;
 699         case BTA_HL_MCA_ABORT_IND_EVT:
 700             if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
 701                 bta_hl_find_mdl_idx( app_idx,  mcl_idx,p_msg->mca_evt.mca_data.abort_ind.mdl_id, &mdl_idx))
 702             {
 703                 found = TRUE;
 704             }
 705             break;
 706         case BTA_HL_MCA_ABORT_CFM_EVT:
 707             if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx,  &mcl_idx) &&
 708                 bta_hl_find_mdl_idx( app_idx,  mcl_idx,  p_msg->mca_evt.mca_data.abort_cfm.mdl_id, &mdl_idx))
 709             {
 710                 found = TRUE;
 711             }
 712             break;
 713         case BTA_HL_CI_GET_TX_DATA_EVT:
 714         case BTA_HL_CI_PUT_RX_DATA_EVT:
 715             if (bta_hl_find_mdl_idx_using_handle(p_msg->ci_get_put_data.mdl_handle, &app_idx, &mcl_idx, &mdl_idx))
 716             {
 717                 found = TRUE;
 718             }
 719             break;
 720         case BTA_HL_CI_GET_ECHO_DATA_EVT:
 721         case BTA_HL_CI_PUT_ECHO_DATA_EVT:
 722             if (bta_hl_find_mcl_idx_using_handle(p_msg->ci_get_put_echo_data.mcl_handle, &app_idx, &mcl_idx))
 723             {
 724                 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
 725                 mdl_idx = p_mcb->echo_mdl_idx;
 726                 found = TRUE;
 727             }
 728             break;
 729
 730         default:
 731             break;
 732
 733     }
 734
 735     if (found)
 736     {
 737         *p_app_idx = app_idx;
 738         *p_mcl_idx = mcl_idx;
 739         *p_mdl_idx = mdl_idx;
 740     }
 741 #if BTA_HL_DEBUG == TRUE
 742     if (!found)
 743     {
 744         APPL_TRACE_DEBUG("bta_hl_find_dch_cb_indexes event=%s found=%d app_idx=%d mcl_idx=%d mdl_idx=%d",
 745                           bta_hl_evt_code(p_msg->hdr.event), found, *p_app_idx, *p_mcl_idx, *p_mdl_idx  );
 746     }
 747 #endif
 748
 749     return found;
 750 }
 751
 752 /*******************************************************************************
 753 **
 754 ** Function      bta_hl_allocate_mdl_id
 755 **
 756 ** Description  This function allocates a MDL ID
 757 **
 758 ** Returns      UINT16 - MDL ID
 759 **
 760 *******************************************************************************/
 761 UINT16  bta_hl_allocate_mdl_id(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx )
 762 {
 763     UINT16  mdl_id=0;
 764     tBTA_HL_MCL_CB      *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
 765     BOOLEAN duplicate_id;
 766     UINT8 i, mdl_cfg_idx;
 767
 768     do
 769     {
 770         duplicate_id = FALSE;
 771         mdl_id = ((mdl_id+1) & 0xFEFF);
 772         /* check mdl_ids that are used for the current conenctions */
 773         for (i=0; i< BTA_HL_NUM_MDLS_PER_MCL; i++)
 774         {
 775             if (p_mcb->mdl[i].in_use &&
 776                 (i != mdl_idx) &&
 777                 (p_mcb->mdl[i].mdl_id == mdl_id) )
 778             {
 779                 duplicate_id = TRUE;
 780                 break;
 781             }
 782         }
 783
 784         if (duplicate_id)
 785         {
 786             /* start from the beginning to get another MDL value*/
 787             continue;
 788         }
 789         else
 790         {
 791             /* check mdl_ids that are stored in the persistent memory */
 792             if (bta_hl_find_mdl_cfg_idx(app_idx,mcl_idx, mdl_id, &mdl_cfg_idx))
 793             {
 794                 duplicate_id = TRUE;
 795             }
 796             else
 797             {
 798                 /* found a new MDL value */
 799                 break;
 800             }
 801         }
 802
 803     }while (TRUE);
 804
 805 #if BTA_HL_DEBUG == TRUE
 806     APPL_TRACE_DEBUG("bta_hl_allocate_mdl OK mdl_id=%d",  mdl_id);
 807 #endif
 808     return mdl_id;
 809 }
 810 /*******************************************************************************
 811 **
 812 ** Function      bta_hl_find_mdl_idx
 813 **
 814 ** Description  This function finds the MDL index based on mdl_id
 815 **
 816 ** Returns      BOOLEAN TRUE-found
 817 **
 818 *******************************************************************************/
 819 BOOLEAN bta_hl_find_mdl_idx(UINT8 app_idx, UINT8 mcl_idx, UINT16 mdl_id,
 820                             UINT8 *p_mdl_idx)
 821 {
 822     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
 823     BOOLEAN found=FALSE;
 824     UINT8 i;
 825
 826     for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
 827     {
 828         if (p_mcb->mdl[i].in_use  &&
 829             (mdl_id !=0) &&
 830             (p_mcb->mdl[i].mdl_id== mdl_id))
 831         {
 832             found = TRUE;
 833             *p_mdl_idx = i;
 834             break;
 835         }
 836     }
 837
 838 #if BTA_HL_DEBUG == TRUE
 839     if (!found)
 840     {
 841         APPL_TRACE_DEBUG("bta_hl_find_mdl_idx found=%d mdl_id=%d mdl_idx=%d ",
 842                           found, mdl_id, i);
 843     }
 844 #endif
 845
 846     return found;
 847 }
 848
 849 /*******************************************************************************
 850 **
 851 ** Function      bta_hl_find_an_active_mdl_idx
 852 **
 853 ** Description  This function finds an active MDL
 854 **
 855 ** Returns      BOOLEAN TRUE-found
 856 **
 857 *******************************************************************************/
 858 BOOLEAN bta_hl_find_an_active_mdl_idx(UINT8 app_idx, UINT8 mcl_idx,
 859                                       UINT8 *p_mdl_idx)
 860 {
 861     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
 862     BOOLEAN found=FALSE;
 863     UINT8 i;
 864
 865     for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
 866     {
 867         if (p_mcb->mdl[i].in_use  &&
 868             (p_mcb->mdl[i].dch_state == BTA_HL_DCH_OPEN_ST))
 869         {
 870             found = TRUE;
 871             *p_mdl_idx = i;
 872             break;
 873         }
 874     }
 875
 876 #if BTA_HL_DEBUG == TRUE
 877     if (found)
 878     {
 879         APPL_TRACE_DEBUG("bta_hl_find_an_opened_mdl_idx found=%d app_idx=%d mcl_idx=%d mdl_idx=%d",
 880                           found, app_idx, mcl_idx, i);
 881     }
 882 #endif
 883
 884     return found;
 885 }
 886
 887 /*******************************************************************************
 888 **
 889 ** Function      bta_hl_find_dch_setup_mdl_idx
 890 **
 891 ** Description  This function finds a MDL which in the DCH setup state
 892 **
 893 ** Returns      BOOLEAN TRUE-found
 894 **
 895 *******************************************************************************/
 896 BOOLEAN bta_hl_find_dch_setup_mdl_idx(UINT8 app_idx, UINT8 mcl_idx,
 897                                       UINT8 *p_mdl_idx)
 898 {
 899     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
 900     BOOLEAN found=FALSE;
 901     UINT8 i;
 902
 903     for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
 904     {
 905         if (p_mcb->mdl[i].in_use  &&
 906             (p_mcb->mdl[i].dch_state == BTA_HL_DCH_OPENING_ST))
 907         {
 908             found = TRUE;
 909             *p_mdl_idx = i;
 910             break;
 911         }
 912     }
 913
 914 #if BTA_HL_DEBUG == TRUE
 915     if (found)
 916     {
 917         APPL_TRACE_DEBUG("bta_hl_find_dch_setup_mdl_idx found=%d app_idx=%d mcl_idx=%d mdl_idx=%d",
 918                           found, app_idx, mcl_idx, i);
 919     }
 920 #endif
 921
 922     return found;
 923 }
 924
 925 /*******************************************************************************
 926 **
 927 ** Function      bta_hl_find_an_in_use_mcl_idx
 928 **
 929 ** Description  This function finds an in-use MCL control block index
 930 **
 931 ** Returns      BOOLEAN TRUE-found
 932 **
 933 *******************************************************************************/
 934 BOOLEAN bta_hl_find_an_in_use_mcl_idx(UINT8 app_idx,
 935                                       UINT8 *p_mcl_idx)
 936 {
 937     tBTA_HL_MCL_CB      *p_mcb;
 938     BOOLEAN found=FALSE;
 939     UINT8 i;
 940
 941     for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
 942     {
 943         p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, i);
 944         if (p_mcb->in_use  &&
 945             (p_mcb->cch_state != BTA_HL_CCH_IDLE_ST))
 946         {
 947             found = TRUE;
 948             *p_mcl_idx = i;
 949             break;
 950         }
 951     }
 952
 953 #if BTA_HL_DEBUG == TRUE
 954     if (found)
 955     {
 956         APPL_TRACE_DEBUG("bta_hl_find_an_in_use_mcl_idx found=%d app_idx=%d mcl_idx=%d ",
 957                           found, app_idx, i);
 958     }
 959 #endif
 960
 961     return found;
 962 }
 963
 964
 965 /*******************************************************************************
 966 **
 967 ** Function      bta_hl_find_an_in_use_app_idx
 968 **
 969 ** Description  This function finds an in-use application control block index
 970 **
 971 ** Returns      BOOLEAN TRUE-found
 972 **
 973 *******************************************************************************/
 974 BOOLEAN bta_hl_find_an_in_use_app_idx(UINT8 *p_app_idx)
 975 {
 976     tBTA_HL_APP_CB      *p_acb ;
 977     BOOLEAN found=FALSE;
 978     UINT8 i;
 979
 980     for (i=0; i < BTA_HL_NUM_APPS ; i ++)
 981     {
 982         p_acb  = BTA_HL_GET_APP_CB_PTR(i);
 983         if (p_acb->in_use)
 984         {
 985             found = TRUE;
 986             *p_app_idx = i;
 987             break;
 988         }
 989     }
 990
 991 #if BTA_HL_DEBUG == TRUE
 992     if (found)
 993     {
 994         APPL_TRACE_DEBUG("bta_hl_find_an_in_use_app_idx found=%d app_idx=%d ",
 995                           found, i);
 996     }
 997 #endif
 998
 999     return found;
1000 }
1001 /*******************************************************************************
1002 **
1003 ** Function      bta_hl_find_app_idx
1004 **
1005 ** Description  This function finds the application control block index based on
1006 **              the application ID
1007 **
1008 ** Returns      BOOLEAN TRUE-found
1009 **
1010 *******************************************************************************/
1011 BOOLEAN bta_hl_find_app_idx(UINT8 app_id, UINT8 *p_app_idx)
1012 {
1013     BOOLEAN found=FALSE;
1014     UINT8 i;
1015
1016     for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1017     {
1018         if (bta_hl_cb.acb[i].in_use &&
1019             (bta_hl_cb.acb[i].app_id == app_id))
1020         {
1021             found = TRUE;
1022             *p_app_idx = i;
1023             break;
1024         }
1025     }
1026
1027 #if BTA_HL_DEBUG == TRUE
1028     APPL_TRACE_DEBUG("bta_hl_find_app_idx found=%d app_id=%d idx=%d ",
1029                       found, app_id, i);
1030 #endif
1031
1032     return found;
1033 }
1034
1035
1036 /*******************************************************************************
1037 **
1038 ** Function      bta_hl_find_app_idx_using_handle
1039 **
1040 ** Description  This function finds the application control block index based on
1041 **              the application handle
1042 **
1043 ** Returns      BOOLEAN TRUE-found
1044 **
1045 *******************************************************************************/
1046 BOOLEAN bta_hl_find_app_idx_using_handle(tBTA_HL_APP_HANDLE app_handle,
1047                                          UINT8 *p_app_idx)
1048 {
1049     BOOLEAN found=FALSE;
1050     UINT8 i;
1051
1052     for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1053     {
1054         if (bta_hl_cb.acb[i].in_use &&
1055             (bta_hl_cb.acb[i].app_handle == app_handle))
1056         {
1057             found = TRUE;
1058             *p_app_idx = i;
1059             break;
1060         }
1061     }
1062
1063 #if BTA_HL_DEBUG == TRUE
1064     if (!found)
1065     {
1066         APPL_TRACE_DEBUG("bta_hl_find_app_idx_using_mca_handle status=%d handle=%d app_idx=%d ",
1067                           found, app_handle , i);
1068     }
1069 #endif
1070
1071     return found;
1072 }
1073
1074
1075 /*******************************************************************************
1076 **
1077 ** Function      bta_hl_find_mcl_idx_using_handle
1078 **
1079 ** Description  This function finds the MCL control block index based on
1080 **              the MCL handle
1081 **
1082 ** Returns      BOOLEAN TRUE-found
1083 **
1084 *******************************************************************************/
1085 BOOLEAN bta_hl_find_mcl_idx_using_handle( tBTA_HL_MCL_HANDLE mcl_handle,
1086                                           UINT8 *p_app_idx, UINT8 *p_mcl_idx)
1087 {
1088     tBTA_HL_APP_CB  *p_acb;
1089     BOOLEAN         found=FALSE;
1090     UINT8 i = 0,j = 0;
1091
1092     for (i=0; i<BTA_HL_NUM_APPS; i++)
1093     {
1094         p_acb = BTA_HL_GET_APP_CB_PTR(i);
1095         if (p_acb->in_use)
1096         {
1097             for (j=0; j < BTA_HL_NUM_MCLS ; j++)
1098             {
1099                 if ( p_acb->mcb[j].mcl_handle == mcl_handle )
1100                 {
1101                     found = TRUE;
1102                     *p_app_idx = i;
1103                     *p_mcl_idx = j;
1104                     break;
1105                 }
1106             }
1107         }
1108     }
1109
1110 #if BTA_HL_DEBUG == TRUE
1111     if (!found)
1112     {
1113         APPL_TRACE_DEBUG("bta_hl_find_mcl_idx_using_handle found=%d app_idx=%d mcl_idx=%d",
1114                           found, i, j);
1115     }
1116 #endif
1117     return found;
1118 }
1119
1120 /*******************************************************************************
1121 **
1122 ** Function      bta_hl_find_mcl_idx
1123 **
1124 ** Description  This function finds the MCL control block index based on
1125 **              the peer BD address
1126 **
1127 ** Returns      BOOLEAN TRUE-found
1128 **
1129 *******************************************************************************/
1130 BOOLEAN bta_hl_find_mcl_idx(UINT8 app_idx, BD_ADDR p_bd_addr, UINT8 *p_mcl_idx)
1131 {
1132     BOOLEAN found=FALSE;
1133     UINT8 i;
1134
1135     for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
1136     {
1137         if (bta_hl_cb.acb[app_idx].mcb[i].in_use &&
1138             (!memcmp (bta_hl_cb.acb[app_idx].mcb[i].bd_addr, p_bd_addr, BD_ADDR_LEN)))
1139         {
1140             found = TRUE;
1141             *p_mcl_idx = i;
1142             break;
1143         }
1144     }
1145
1146 #if BTA_HL_DEBUG == TRUE
1147     if (!found)
1148     {
1149         APPL_TRACE_DEBUG("bta_hl_find_mcl_idx found=%d idx=%d",
1150                           found, i);
1151     }
1152 #endif
1153     return found;
1154 }
1155
1156
1157
1158 /*******************************************************************************
1159 **
1160 ** Function      bta_hl_find_mdl_idx_using_handle
1161 **
1162 ** Description  This function finds the MDL control block index based on
1163 **              the MDL handle
1164 **
1165 ** Returns      BOOLEAN TRUE-found
1166 **
1167 *******************************************************************************/
1168 BOOLEAN bta_hl_find_mdl_idx_using_handle(tBTA_HL_MDL_HANDLE mdl_handle,
1169                                          UINT8 *p_app_idx,UINT8 *p_mcl_idx,
1170                                          UINT8 *p_mdl_idx)
1171 {
1172     tBTA_HL_APP_CB      *p_acb;
1173     tBTA_HL_MCL_CB      *p_mcb;
1174     tBTA_HL_MDL_CB      *p_dcb;
1175     BOOLEAN found=FALSE;
1176     UINT8 i,j,k;
1177
1178     for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1179     {
1180         p_acb = BTA_HL_GET_APP_CB_PTR(i);
1181         if (p_acb->in_use)
1182         {
1183             for (j=0; j< BTA_HL_NUM_MCLS; j++)
1184             {
1185                 p_mcb = BTA_HL_GET_MCL_CB_PTR(i,j);
1186                 if (p_mcb->in_use)
1187                 {
1188                     for (k=0; k< BTA_HL_NUM_MDLS_PER_MCL; k++)
1189                     {
1190                         p_dcb = BTA_HL_GET_MDL_CB_PTR(i,j,k);
1191                         if (p_dcb->in_use)
1192                         {
1193                             if (p_dcb->mdl_handle == mdl_handle)
1194                             {
1195                                 found = TRUE;
1196                                 *p_app_idx = i;
1197                                 *p_mcl_idx =j;
1198                                 *p_mdl_idx = k;
1199                                 break;
1200                             }
1201                         }
1202                     }
1203                 }
1204             }
1205         }
1206     }
1207
1208
1209 #if BTA_HL_DEBUG == TRUE
1210     if (!found)
1211     {
1212         APPL_TRACE_DEBUG("bta_hl_find_mdl_idx_using_handle found=%d mdl_handle=%d  ",
1213                           found, mdl_handle);
1214     }
1215 #endif
1216     return found;
1217 }
1218 /*******************************************************************************
1219 **
1220 ** Function      bta_hl_is_the_first_reliable_existed
1221 **
1222 ** Description  This function checks whether the first reliable DCH channel
1223 **              has been setup on the MCL or not
1224 **
1225 ** Returns      BOOLEAN - TRUE exist
1226 **                        FALSE does not exist
1227 **
1228 *******************************************************************************/
1229 BOOLEAN bta_hl_is_the_first_reliable_existed(UINT8 app_idx, UINT8 mcl_idx )
1230 {
1231     tBTA_HL_MCL_CB      *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1232     BOOLEAN is_existed =FALSE;
1233     UINT8 i ;
1234
1235     for (i=0; i< BTA_HL_NUM_MDLS_PER_MCL; i++)
1236     {
1237         if (p_mcb->mdl[i].in_use && p_mcb->mdl[i].is_the_first_reliable)
1238         {
1239             is_existed = TRUE;
1240             break;
1241         }
1242     }
1243
1244 #if BTA_HL_DEBUG == TRUE
1245     APPL_TRACE_DEBUG("bta_hl_is_the_first_reliable_existed is_existed=%d  ",is_existed );
1246 #endif
1247     return is_existed;
1248 }
1249
1250 /*******************************************************************************
1251 **
1252 ** Function      bta_hl_find_non_active_mdl_cfg
1253 **
1254 ** Description  This function finds a valid MDL configiration index and this
1255 **              MDL ID is not active
1256 **
1257 ** Returns      BOOLEAN - TRUE found
1258 **                        FALSE not found
1259 **
1260 *******************************************************************************/
1261 BOOLEAN  bta_hl_find_non_active_mdl_cfg(UINT8 app_idx, UINT8 start_mdl_cfg_idx,
1262                                         UINT8 *p_mdl_cfg_idx)
1263 {
1264
1265     tBTA_HL_MCL_CB      *p_mcb;
1266     tBTA_HL_MDL_CB      *p_dcb;
1267     tBTA_HL_MDL_CFG     *p_mdl;
1268     BOOLEAN             mdl_in_use;
1269     BOOLEAN             found = FALSE;
1270     UINT8               i,j,k;
1271
1272     for (i = start_mdl_cfg_idx; i< BTA_HL_NUM_MDL_CFGS; i++)
1273     {
1274         mdl_in_use = FALSE;
1275         p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1276         for (j=0; j< BTA_HL_NUM_MCLS; j++)
1277         {
1278             p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, j);
1279             if (p_mcb->in_use &&
1280                 !memcmp(p_mdl->peer_bd_addr,p_mcb->bd_addr,BD_ADDR_LEN))
1281             {
1282
1283                 for (k=0; k<BTA_HL_NUM_MDLS_PER_MCL; k++)
1284                 {
1285                     p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, j, k);
1286
1287                     if (p_dcb->in_use &&  p_mdl->mdl_id == p_dcb->mdl_id)
1288                     {
1289                         mdl_in_use = TRUE;
1290                         break;
1291                     }
1292                 }
1293             }
1294
1295             if (mdl_in_use)
1296             {
1297                 break;
1298             }
1299         }
1300
1301         if (!mdl_in_use)
1302         {
1303             *p_mdl_cfg_idx = i;
1304             found = TRUE;
1305             break;
1306         }
1307     }
1308
1309     return found;
1310 }
1311
1312 /*******************************************************************************
1313 **
1314 ** Function      bta_hl_find_mdl_cfg_idx
1315 **
1316 ** Description  This function finds an available MDL configuration index
1317 **
1318 ** Returns      BOOLEAN - TRUE found
1319 **                        FALSE not found
1320 **
1321 *******************************************************************************/
1322 BOOLEAN  bta_hl_find_avail_mdl_cfg_idx(UINT8 app_idx, UINT8 mcl_idx,
1323                                        UINT8 *p_mdl_cfg_idx)
1324 {
1325     tBTA_HL_MDL_CFG     *p_mdl, *p_mdl1, *p_mdl2;
1326     UINT8               i;
1327     BOOLEAN             found=FALSE;
1328     UINT8               first_mdl_cfg_idx, second_mdl_cfg_idx, older_mdl_cfg_idx;
1329     BOOLEAN             done;
1330     UNUSED(mcl_idx);
1331
1332     for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1333     {
1334         p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1335         if (!p_mdl->active  )
1336         {
1337             /* found an unused space to store mdl cfg*/
1338             found=TRUE;
1339             *p_mdl_cfg_idx =i;
1340             break;
1341         }
1342     }
1343
1344     if (!found)
1345     {
1346         /* all available mdl cfg spaces are in use so we need to find the mdl cfg which is
1347         not currently in use and has the the oldest time stamp to remove*/
1348
1349         found = TRUE;
1350         if (bta_hl_find_non_active_mdl_cfg(app_idx,0, &first_mdl_cfg_idx))
1351         {
1352             if (bta_hl_find_non_active_mdl_cfg(app_idx,(UINT8) (first_mdl_cfg_idx+1), &second_mdl_cfg_idx))
1353             {
1354                 done = FALSE;
1355                 while (!done)
1356                 {
1357                     p_mdl1 = BTA_HL_GET_MDL_CFG_PTR(app_idx, first_mdl_cfg_idx);
1358                     p_mdl2 = BTA_HL_GET_MDL_CFG_PTR(app_idx, second_mdl_cfg_idx);
1359
1360                     if (p_mdl1->time < p_mdl2->time)
1361                     {
1362                         older_mdl_cfg_idx =  first_mdl_cfg_idx;
1363                     }
1364                     else
1365                     {
1366                         older_mdl_cfg_idx =  second_mdl_cfg_idx;
1367                     }
1368
1369                     if (bta_hl_find_non_active_mdl_cfg(app_idx,(UINT8) (second_mdl_cfg_idx+1), &second_mdl_cfg_idx))
1370                     {
1371                         first_mdl_cfg_idx = older_mdl_cfg_idx;
1372                     }
1373                     else
1374                     {
1375                         done = TRUE;
1376                     }
1377                 }
1378
1379                 *p_mdl_cfg_idx = older_mdl_cfg_idx;
1380
1381             }
1382             else
1383             {
1384                 *p_mdl_cfg_idx = first_mdl_cfg_idx;
1385             }
1386
1387         }
1388         else
1389         {
1390             found = FALSE;
1391         }
1392     }
1393
1394 #if BTA_HL_DEBUG == TRUE
1395     if (!found)
1396     {
1397         APPL_TRACE_DEBUG("bta_hl_find_avail_mdl_cfg_idx found=%d mdl_cfg_idx=%d ",found, *p_mdl_cfg_idx  );
1398     }
1399 #endif
1400
1401     return found;
1402
1403
1404 }
1405
1406 /*******************************************************************************
1407 **
1408 ** Function      bta_hl_find_mdl_cfg_idx
1409 **
1410 ** Description  This function finds the MDL configuration index based on
1411 **              the MDL ID
1412 **
1413 ** Returns      BOOLEAN - TRUE found
1414 **                        FALSE not found
1415 **
1416 *******************************************************************************/
1417 BOOLEAN  bta_hl_find_mdl_cfg_idx(UINT8 app_idx, UINT8 mcl_idx,
1418                                  tBTA_HL_MDL_ID mdl_id, UINT8 *p_mdl_cfg_idx)
1419 {
1420     tBTA_HL_MCL_CB      *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1421     tBTA_HL_MDL_CFG     *p_mdl;
1422     UINT8 i ;
1423     BOOLEAN found=FALSE;
1424
1425     *p_mdl_cfg_idx = 0;
1426     for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1427     {
1428         p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1429         if(p_mdl->active)
1430             APPL_TRACE_DEBUG("bta_hl_find_mdl_cfg_idx: mdl_id =%d, p_mdl->mdl_id=%d",mdl_id,
1431                               p_mdl->mdl_id);
1432         if (p_mdl->active &&
1433             (!memcmp (p_mcb->bd_addr, p_mdl->peer_bd_addr, BD_ADDR_LEN))&&
1434             (p_mdl->mdl_id == mdl_id))
1435         {
1436             found=TRUE;
1437             *p_mdl_cfg_idx =i;
1438             break;
1439         }
1440     }
1441
1442 #if BTA_HL_DEBUG == TRUE
1443     if (!found)
1444     {
1445         APPL_TRACE_DEBUG("bta_hl_find_mdl_cfg_idx found=%d mdl_cfg_idx=%d ",found, i );
1446     }
1447 #endif
1448
1449     return found;
1450
1451
1452 }
1453
1454
1455 /*******************************************************************************
1456 **
1457 ** Function      bta_hl_get_cur_time
1458 **
1459 ** Description  This function get the cuurent time value
1460 **
1461 ** Returns      BOOLEAN - TRUE found
1462 **                        FALSE not found
1463 **
1464 *******************************************************************************/
1465 BOOLEAN  bta_hl_get_cur_time(UINT8 app_idx, UINT8 *p_cur_time)
1466 {
1467     tBTA_HL_MDL_CFG     *p_mdl;
1468     UINT8 i, j, time_latest, time;
1469     BOOLEAN found=FALSE, result=TRUE;
1470
1471     for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1472     {
1473         p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1474         if (p_mdl->active)
1475         {
1476             found=TRUE;
1477             time_latest = p_mdl->time;
1478             for (j=(i+1); j< BTA_HL_NUM_MDL_CFGS; j++ )
1479             {
1480                 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, j);
1481                 if (p_mdl->active)
1482                 {
1483                     time = p_mdl->time;
1484                     if (time > time_latest)
1485                     {
1486                         time_latest = time;
1487                     }
1488                 }
1489             }
1490             break;
1491         }
1492     }
1493
1494
1495     if (found)
1496     {
1497         if (time_latest < BTA_HL_MAX_TIME)
1498         {
1499             *p_cur_time = time_latest+1;
1500         }
1501         else
1502         {
1503             /* need to wrap around */
1504             result = FALSE;
1505         }
1506     }
1507     else
1508     {
1509         *p_cur_time = BTA_HL_MIN_TIME;
1510     }
1511
1512 #if BTA_HL_DEBUG == TRUE
1513     if (!result)
1514     {
1515         APPL_TRACE_DEBUG("bta_hl_get_cur_time result=%s cur_time=%d",
1516                           (result?"OK":"FAIL"), *p_cur_time);
1517     }
1518 #endif
1519
1520     return result;
1521 }
1522
1523 /*******************************************************************************
1524 **
1525 ** Function      bta_hl_sort_cfg_time_idx
1526 **
1527 ** Description  This function sort the mdl configuration idx stored in array a
1528 **              based on decending time value
1529 **
1530 ** Returns      BOOLEAN - TRUE found
1531 **                        FALSE not found
1532 **
1533 *******************************************************************************/
1534 void bta_hl_sort_cfg_time_idx(UINT8 app_idx, UINT8 *a, UINT8 n)
1535 {
1536     tBTA_HL_APP_CB      *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1537     UINT8 temp_time, temp_idx;
1538     INT16 i, j;
1539     for (i = 1; i < n; ++i)
1540     {
1541         temp_idx = a[i];
1542         temp_time = p_acb->mdl_cfg[temp_idx].time;
1543         j = i - 1;
1544         while ((j >= 0) && (temp_time < p_acb->mdl_cfg[a[j]].time))
1545         {
1546             a[j + 1] = a[j];
1547             --j;
1548         }
1549         a[j + 1] = temp_idx;
1550     }
1551 }
1552
1553 /*******************************************************************************
1554 **
1555 ** Function      bta_hl_compact_mdl_cfg_time
1556 **
1557 ** Description  This function finds the MDL configuration index based on
1558 **              the MDL ID
1559 **
1560 ** Returns      BOOLEAN - TRUE found
1561 **                        FALSE not found
1562 **
1563 *******************************************************************************/
1564 void  bta_hl_compact_mdl_cfg_time(UINT8 app_idx, UINT8 mdep_id)
1565 {
1566     tBTA_HL_MDL_CFG     *p_mdl;
1567     UINT8 i, time_min, cnt=0;
1568     UINT8   s_arr[BTA_HL_NUM_MDL_CFGS];
1569
1570
1571     for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1572     {
1573         p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1574         if (p_mdl->active )
1575         {
1576             s_arr[cnt]= i;
1577             cnt++;
1578         }
1579     }
1580
1581
1582
1583 #if BTA_HL_DEBUG == TRUE
1584     APPL_TRACE_DEBUG("bta_hl_compact_mdl_cfg_time cnt=%d ",cnt );
1585 #endif
1586
1587
1588     if (cnt)
1589     {
1590         bta_hl_sort_cfg_time_idx(app_idx, s_arr, cnt);
1591         time_min = BTA_HL_MIN_TIME;
1592         for (i=0;i<cnt; i++)
1593         {
1594             p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, s_arr[i]);
1595             p_mdl->time = time_min + i;
1596             bta_hl_co_save_mdl(mdep_id, s_arr[i], p_mdl);
1597         }
1598     }
1599
1600
1601 }
1602
1603
1604
1605 /*******************************************************************************
1606 **
1607 ** Function      bta_hl_is_mdl_exsit_in_mcl
1608 **
1609 ** Description  This function checks whether the MDL ID
1610 **              has already existed in teh MCL or not
1611 **
1612 ** Returns      BOOLEAN - TRUE exist
1613 **                        FALSE does not exist
1614 **
1615 *******************************************************************************/
1616 BOOLEAN  bta_hl_is_mdl_exsit_in_mcl(UINT8 app_idx, BD_ADDR bd_addr,
1617                                     tBTA_HL_MDL_ID mdl_id)
1618 {
1619     tBTA_HL_MDL_CFG     *p_mdl;
1620     BOOLEAN             found = FALSE;
1621     UINT8               i;
1622
1623     for (i = 0; i< BTA_HL_NUM_MDL_CFGS; i++)
1624     {
1625         p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1626         if (p_mdl->active &&
1627             !memcmp(p_mdl->peer_bd_addr, bd_addr,BD_ADDR_LEN))
1628         {
1629             if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS)
1630             {
1631                 if (p_mdl->mdl_id == mdl_id)
1632                 {
1633                     found = TRUE;
1634                     break;
1635                 }
1636             }
1637             else
1638             {
1639                 found = TRUE;
1640                 break;
1641             }
1642         }
1643     }
1644
1645     return found;
1646 }
1647
1648 /*******************************************************************************
1649 **
1650 ** Function      bta_hl_delete_mdl_cfg
1651 **
1652 ** Description  This function delete the specified MDL ID
1653 **
1654 ** Returns      BOOLEAN - TRUE Success
1655 **                        FALSE Failed
1656 **
1657 *******************************************************************************/
1658 BOOLEAN  bta_hl_delete_mdl_cfg(UINT8 app_idx, BD_ADDR bd_addr,
1659                                tBTA_HL_MDL_ID mdl_id)
1660 {
1661     tBTA_HL_MDL_CFG     *p_mdl;
1662     BOOLEAN             success = FALSE;
1663     UINT8               i;
1664
1665     for (i = 0; i< BTA_HL_NUM_MDL_CFGS; i++)
1666     {
1667         p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1668         if (p_mdl->active &&
1669             !memcmp(p_mdl->peer_bd_addr, bd_addr,BD_ADDR_LEN))
1670         {
1671             if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS)
1672             {
1673                 if (p_mdl->mdl_id == mdl_id)
1674                 {
1675                     bta_hl_co_delete_mdl(p_mdl->local_mdep_id, i);
1676                     memset(p_mdl, 0, sizeof(tBTA_HL_MDL_CFG));
1677                     success = TRUE;
1678                     break;
1679                 }
1680             }
1681             else
1682             {
1683                 bta_hl_co_delete_mdl(p_mdl->local_mdep_id, i);
1684                 memset(p_mdl, 0, sizeof(tBTA_HL_MDL_CFG));
1685                 success = TRUE;
1686             }
1687         }
1688     }
1689
1690     return success;
1691 }
1692
1693
1694 /*******************************************************************************
1695 **
1696 ** Function      bta_hl_is_mdl_value_valid
1697 **
1698 **
1699 ** Description  This function checks the specified MDL ID is in valid range or not
1700 **
1701 ** Returns      BOOLEAN - TRUE Success
1702 **                        FALSE Failed
1703 **
1704 ** note:   mdl_id range   0x0000 reserved,
1705 **                        0x0001-oxFEFF dynamic range,
1706 **                        0xFF00-0xFFFE reserved,
1707 **                        0xFFFF indicates all MDLs (for delete operation only)
1708 **
1709 *******************************************************************************/
1710 BOOLEAN  bta_hl_is_mdl_value_valid(tBTA_HL_MDL_ID mdl_id)
1711 {
1712     BOOLEAN             status = TRUE;
1713
1714     if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS)
1715     {
1716         if (mdl_id != 0)
1717         {
1718             if (mdl_id > BTA_HL_MAX_MDL_VAL )
1719             {
1720                 status = FALSE;
1721             }
1722         }
1723         else
1724         {
1725             status = FALSE;
1726         }
1727     }
1728
1729     return status;
1730 }
1731
1732 /*******************************************************************************
1733 **
1734 ** Function      bta_hl_find_mdep_cfg_idx
1735 **
1736 ** Description  This function finds the MDEP configuration index based
1737 **                on the local MDEP ID
1738 **
1739 ** Returns      BOOLEAN - TRUE found
1740 **                        FALSE not found
1741 **
1742 *******************************************************************************/
1743 BOOLEAN bta_hl_find_mdep_cfg_idx(UINT8 app_idx,  tBTA_HL_MDEP_ID local_mdep_id,
1744                                  UINT8 *p_mdep_cfg_idx)
1745 {
1746     tBTA_HL_APP_CB      *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1747     tBTA_HL_SUP_FEATURE     *p_sup_feature= &p_acb->sup_feature;
1748     BOOLEAN found =FALSE;
1749     UINT8 i;
1750
1751     for (i=0; i< p_sup_feature->num_of_mdeps; i++)
1752     {
1753         if ( p_sup_feature->mdep[i].mdep_id == local_mdep_id)
1754         {
1755             found = TRUE;
1756             *p_mdep_cfg_idx = i;
1757             break;
1758         }
1759     }
1760
1761 #if BTA_HL_DEBUG == TRUE
1762     if (!found)
1763     {
1764         APPL_TRACE_DEBUG("bta_hl_find_mdep_cfg_idx found=%d mdep_idx=%d local_mdep_id=%d ",
1765                           found,i, local_mdep_id );
1766     }
1767 #endif
1768     return found;
1769 }
1770
1771
1772 /*******************************************************************************
1773 **
1774 ** Function      bta_hl_find_rxtx_apdu_size
1775 **
1776 ** Description  This function finds the maximum APDU rx and tx sizes based on
1777 **              the MDEP configuration data
1778 **
1779 ** Returns      void
1780 **
1781 *******************************************************************************/
1782 void bta_hl_find_rxtx_apdu_size(UINT8 app_idx, UINT8 mdep_cfg_idx,
1783                                 UINT16 *p_rx_apu_size,
1784                                 UINT16 *p_tx_apu_size)
1785 {
1786     tBTA_HL_APP_CB      *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1787     tBTA_HL_MDEP_CFG     *p_mdep_cfg;
1788     UINT8 i;
1789     UINT16 max_rx_apdu_size=0, max_tx_apdu_size=0;
1790
1791     p_mdep_cfg = &p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg;
1792
1793
1794     for (i=0; i< p_mdep_cfg->num_of_mdep_data_types ; i++)
1795     {
1796
1797         if (max_rx_apdu_size < p_mdep_cfg->data_cfg[i].max_rx_apdu_size)
1798         {
1799             max_rx_apdu_size = p_mdep_cfg->data_cfg[i].max_rx_apdu_size;
1800         }
1801
1802         if (max_tx_apdu_size < p_mdep_cfg->data_cfg[i].max_tx_apdu_size)
1803         {
1804             max_tx_apdu_size = p_mdep_cfg->data_cfg[i].max_tx_apdu_size;
1805         }
1806     }
1807
1808
1809     *p_rx_apu_size = max_rx_apdu_size;
1810     *p_tx_apu_size = max_tx_apdu_size;
1811
1812 #if BTA_HL_DEBUG == TRUE
1813     APPL_TRACE_DEBUG("bta_hl_find_rxtx_apdu_size max_rx_apdu_size=%d max_tx_apdu_size=%d ",
1814                       max_rx_apdu_size, max_tx_apdu_size );
1815 #endif
1816
1817
1818 }
1819
1820 /*******************************************************************************
1821 **
1822 ** Function      bta_hl_validate_peer_cfg
1823 **
1824 ** Description  This function validates the peer DCH configuration
1825 **
1826 ** Returns      BOOLEAN - TRUE validation is successful
1827 **                        FALSE validation failed
1828 **
1829 *******************************************************************************/
1830 BOOLEAN bta_hl_validate_peer_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
1831                                  tBTA_HL_MDEP_ID peer_mdep_id,
1832                                  tBTA_HL_MDEP_ROLE peer_mdep_role,
1833                                  UINT8 sdp_idx)
1834 {
1835     tBTA_HL_MCL_CB      *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1836     tBTA_HL_MDL_CB      *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1837     tBTA_HL_SDP_REC     *p_rec;
1838     BOOLEAN peer_found =FALSE;
1839     UINT8 i;
1840
1841     APPL_TRACE_DEBUG("bta_hl_validate_peer_cfg sdp_idx=%d app_idx %d", sdp_idx, app_idx);
1842
1843
1844     if (p_dcb->local_mdep_id == BTA_HL_ECHO_TEST_MDEP_ID)
1845     {
1846         return TRUE;
1847     }
1848
1849     p_rec = &p_mcb->sdp.sdp_rec[sdp_idx];
1850     for (i=0; i< p_rec->num_mdeps; i++)
1851     {
1852         APPL_TRACE_DEBUG("mdep_id %d peer_mdep_id %d",p_rec->mdep_cfg[i].mdep_id , peer_mdep_id);
1853         APPL_TRACE_DEBUG("mdep_role %d peer_mdep_role %d",p_rec->mdep_cfg[i].mdep_role,
1854                           peer_mdep_role)
1855         if ( (p_rec->mdep_cfg[i].mdep_id == peer_mdep_id) &&
1856              (p_rec->mdep_cfg[i].mdep_role == peer_mdep_role))
1857         {
1858             peer_found = TRUE;
1859
1860             break;
1861         }
1862     }
1863
1864 #if BTA_HL_DEBUG == TRUE
1865     if (!peer_found)
1866     {
1867         APPL_TRACE_DEBUG("bta_hl_validate_peer_cfg failed num_mdeps=%d",p_rec->num_mdeps);
1868     }
1869 #endif
1870     return peer_found;
1871 }
1872
1873 /*******************************************************************************
1874 **
1875 ** Function      bta_hl_chk_local_cfg
1876 **
1877 ** Description  This function check whether the local DCH configuration is OK or not
1878 **
1879 ** Returns      tBTA_HL_STATUS - OK - local DCH configuration is OK
1880 **                               NO_FIRST_RELIABLE - the streaming DCH configuration
1881 **                                                   is not OK and it needs to use
1882 **                                                   reliable DCH configuration
1883 **
1884 *******************************************************************************/
1885 tBTA_HL_STATUS bta_hl_chk_local_cfg(UINT8 app_idx, UINT8 mcl_idx,
1886                                     UINT8 mdep_cfg_idx,
1887                                     tBTA_HL_DCH_CFG local_cfg)
1888 {
1889     tBTA_HL_APP_CB      *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1890     tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
1891
1892     if ( mdep_cfg_idx &&
1893          (p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SOURCE) &&
1894          (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx)) &&
1895          (local_cfg != BTA_HL_DCH_CFG_RELIABLE))
1896     {
1897         status =  BTA_HL_STATUS_NO_FIRST_RELIABLE;
1898         APPL_TRACE_ERROR("BTA_HL_STATUS_INVALID_DCH_CFG");
1899     }
1900
1901     return status;
1902 }
1903
1904
1905 /*******************************************************************************
1906 **
1907 ** Function      bta_hl_validate_reconnect_params
1908 **
1909 ** Description  This function validates the reconnect parameters
1910 **
1911 ** Returns      BOOLEAN - TRUE validation is successful
1912 **                        FALSE validation failed
1913 *******************************************************************************/
1914 BOOLEAN bta_hl_validate_reconnect_params(UINT8 app_idx, UINT8 mcl_idx,
1915                                          tBTA_HL_API_DCH_RECONNECT *p_reconnect,
1916                                          UINT8 *p_mdep_cfg_idx, UINT8 *p_mdl_cfg_idx)
1917 {
1918     tBTA_HL_APP_CB      *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1919     tBTA_HL_SUP_FEATURE *p_sup_feature = &p_acb->sup_feature;
1920     UINT8               num_mdeps;
1921     UINT8               mdl_cfg_idx;
1922     BOOLEAN local_mdep_id_found =FALSE;
1923     BOOLEAN mdl_cfg_found =FALSE;
1924     BOOLEAN            status=FALSE;
1925     UINT8 i, in_use_mdl_idx = 0;
1926
1927 #if BTA_HL_DEBUG == TRUE
1928     APPL_TRACE_DEBUG("bta_hl_validate_reconnect_params  mdl_id=%d app_idx=%d", p_reconnect->mdl_id, app_idx);
1929 #endif
1930     if (bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, p_reconnect->mdl_id, &mdl_cfg_idx))
1931     {
1932         mdl_cfg_found = TRUE;
1933     }
1934
1935 #if BTA_HL_DEBUG == TRUE
1936     if (!mdl_cfg_found)
1937     {
1938         APPL_TRACE_DEBUG("mdl_cfg_found not found");
1939     }
1940 #endif
1941
1942
1943     if (mdl_cfg_found)
1944     {
1945         num_mdeps = p_sup_feature->num_of_mdeps;
1946         for (i=0; i< num_mdeps ; i++)
1947         {
1948             if ( p_sup_feature->mdep[i].mdep_id == p_acb->mdl_cfg[mdl_cfg_idx].local_mdep_id)
1949             {
1950                 local_mdep_id_found = TRUE;
1951                 *p_mdep_cfg_idx =i;
1952                 *p_mdl_cfg_idx = mdl_cfg_idx;
1953                 break;
1954             }
1955         }
1956     }
1957
1958 #if BTA_HL_DEBUG == TRUE
1959     if (!local_mdep_id_found)
1960     {
1961         APPL_TRACE_DEBUG("local_mdep_id not found");
1962     }
1963 #endif
1964
1965
1966     if (local_mdep_id_found)
1967     {
1968         if (!bta_hl_find_mdl_idx(app_idx,mcl_idx, p_reconnect->mdl_id, &in_use_mdl_idx))
1969         {
1970             status= TRUE;
1971         }
1972         else
1973         {
1974             APPL_TRACE_ERROR("mdl_id=%d is curreltly in use",p_reconnect->mdl_id);
1975         }
1976     }
1977
1978 #if BTA_HL_DEBUG == TRUE
1979     if (!status)
1980     {
1981         APPL_TRACE_DEBUG("Reconnect validation failed local_mdep_id found=%d mdl_cfg_idx found=%d in_use_mdl_idx=%d ",
1982                           local_mdep_id_found,  mdl_cfg_found, in_use_mdl_idx);
1983     }
1984 #endif
1985     return status;
1986 }
1987
1988 /*******************************************************************************
1989 **
1990 ** Function      bta_hl_find_avail_mcl_idx
1991 **
1992 ** Returns      BOOLEAN - TRUE found
1993 **                        FALSE not found
1994 **
1995 *******************************************************************************/
1996 BOOLEAN bta_hl_find_avail_mcl_idx(UINT8 app_idx, UINT8 *p_mcl_idx)
1997 {
1998     BOOLEAN found=FALSE;
1999     UINT8 i;
2000
2001     for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
2002     {
2003         if (!bta_hl_cb.acb[app_idx].mcb[i].in_use)
2004         {
2005             found = TRUE;
2006             *p_mcl_idx = i;
2007             break;
2008         }
2009     }
2010
2011 #if BTA_HL_DEBUG == TRUE
2012     if (!found)
2013     {
2014         APPL_TRACE_DEBUG("bta_hl_find_avail_mcl_idx found=%d idx=%d",
2015                           found, i);
2016     }
2017 #endif
2018     return found;
2019 }
2020
2021
2022
2023 /*******************************************************************************
2024 **
2025 ** Function      bta_hl_find_avail_mdl_idx
2026 **
2027 ** Description  This function finds an available MDL control block index
2028 **
2029 ** Returns      BOOLEAN - TRUE found
2030 **                        FALSE not found
2031 **
2032 *******************************************************************************/
2033 BOOLEAN bta_hl_find_avail_mdl_idx(UINT8 app_idx, UINT8 mcl_idx,
2034                                   UINT8 *p_mdl_idx)
2035 {
2036     tBTA_HL_MCL_CB      *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2037     BOOLEAN found=FALSE;
2038     UINT8 i;
2039
2040     for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
2041     {
2042         if (!p_mcb->mdl[i].in_use)
2043         {
2044             memset((void *)&p_mcb->mdl[i],0, sizeof(tBTA_HL_MDL_CB));
2045             found = TRUE;
2046             *p_mdl_idx = i;
2047             break;
2048         }
2049     }
2050
2051 #if BTA_HL_DEBUG == TRUE
2052     if (!found)
2053     {
2054         APPL_TRACE_DEBUG("bta_hl_find_avail_mdl_idx found=%d idx=%d",
2055                           found, i);
2056     }
2057 #endif
2058     return found;
2059 }
2060
2061 /*******************************************************************************
2062 **
2063 ** Function      bta_hl_is_a_duplicate_id
2064 **
2065 ** Description  This function finds the application has been used or not
2066 **
2067 ** Returns      BOOLEAN - TRUE the app_id is a duplicate ID
2068 **                        FALSE not a duplicate ID
2069 *******************************************************************************/
2070 BOOLEAN bta_hl_is_a_duplicate_id(UINT8 app_id)
2071 {
2072     BOOLEAN is_duplicate=FALSE;
2073     UINT8 i;
2074
2075     for (i=0; i < BTA_HL_NUM_APPS ; i ++)
2076     {
2077         if (bta_hl_cb.acb[i].in_use &&
2078             (bta_hl_cb.acb[i].app_id == app_id))
2079         {
2080             is_duplicate = TRUE;
2081
2082             break;
2083         }
2084     }
2085
2086 #if BTA_HL_DEBUG == TRUE
2087     if (is_duplicate)
2088     {
2089
2090         APPL_TRACE_DEBUG("bta_hl_is_a_duplicate_id app_id=%d is_duplicate=%d",
2091                           app_id, is_duplicate);
2092     }
2093 #endif
2094
2095     return is_duplicate;
2096 }
2097
2098
2099 /*******************************************************************************
2100 **
2101 ** Function      bta_hl_find_avail_app_idx
2102 **
2103 ** Description  This function finds an available application control block index
2104 **
2105 ** Returns      BOOLEAN - TRUE found
2106 **                        FALSE not found
2107 **
2108 *******************************************************************************/
2109 BOOLEAN bta_hl_find_avail_app_idx(UINT8 *p_idx)
2110 {
2111     BOOLEAN found=FALSE;
2112     UINT8 i;
2113
2114     for (i=0; i < BTA_HL_NUM_APPS ; i ++)
2115     {
2116         if (!bta_hl_cb.acb[i].in_use)
2117         {
2118             found = TRUE;
2119             *p_idx = i;
2120             break;
2121         }
2122     }
2123
2124 #if BTA_HL_DEBUG == TRUE
2125     if (!found)
2126     {
2127         APPL_TRACE_DEBUG("bta_hl_find_avail_app_idx found=%d app_idx=%d",
2128                           found, i);
2129     }
2130 #endif
2131     return found;
2132 }
2133
2134 /*******************************************************************************
2135 **
2136 ** Function      bta_hl_app_update
2137 **
2138 ** Description  This function registers an HDP application MCAP and DP
2139 **
2140 ** Returns      tBTA_HL_STATUS -registration status
2141 **
2142 *******************************************************************************/
2143 tBTA_HL_STATUS bta_hl_app_update(UINT8 app_id, BOOLEAN is_register)
2144 {
2145     tBTA_HL_STATUS  status = BTA_HL_STATUS_OK;
2146     tBTA_HL_APP_CB  *p_acb = BTA_HL_GET_APP_CB_PTR(0);
2147     tMCA_CS         mca_cs;
2148     UINT8           i, mdep_idx, num_of_mdeps;
2149     UINT8           mdep_counter = 0;
2150
2151
2152 #if BTA_HL_DEBUG == TRUE
2153     APPL_TRACE_DEBUG("bta_hl_app_update app_id=%d", app_id);
2154 #endif
2155
2156     if (is_register)
2157     {
2158         if ((status == BTA_HL_STATUS_OK) &&
2159         bta_hl_co_get_num_of_mdep(app_id, &num_of_mdeps))
2160         {
2161             for (i=0; i < num_of_mdeps; i++)
2162             {
2163                 mca_cs.type = MCA_TDEP_DATA;
2164                 mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
2165                 mca_cs.p_data_cback = bta_hl_mcap_data_cback;
2166                 /* Find the first available mdep index, and create a MDL Endpoint */
2167                 // make a function later if needed
2168                 for (mdep_idx = 1; mdep_idx < BTA_HL_NUM_MDEPS; mdep_idx++)
2169                 {
2170                     if ( p_acb->sup_feature.mdep[mdep_idx].mdep_id == 0)
2171                     {
2172                         break; /* We found an available index */
2173                     }
2174                     else
2175                     {
2176                         mdep_counter++;
2177                     }
2178                 }
2179                 /* If no available MDEPs, return error */
2180                 if (mdep_idx == BTA_HL_NUM_MDEPS)
2181                 {
2182                     APPL_TRACE_ERROR("bta_hl_app_update: Out of MDEP IDs");
2183                     status = BTA_HL_STATUS_MCAP_REG_FAIL;
2184                     break;
2185                 }
2186                 if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
2187                               &(p_acb->sup_feature.mdep[mdep_idx].mdep_id), &mca_cs) == MCA_SUCCESS)
2188                 {
2189                     if (bta_hl_co_get_mdep_config(app_id,
2190                                                   mdep_idx,
2191                                                   mdep_counter,
2192                                                   p_acb->sup_feature.mdep[mdep_idx].mdep_id,
2193                                                   &p_acb->sup_feature.mdep[mdep_idx].mdep_cfg))
2194                     {
2195                         p_acb->sup_feature.mdep[mdep_idx].ori_app_id = app_id;
2196                         APPL_TRACE_DEBUG("mdep idx %d id %d ori_app_id %d num data type %d",mdep_idx,
2197                                p_acb->sup_feature.mdep[mdep_idx].mdep_id,
2198                                p_acb->sup_feature.mdep[mdep_idx].ori_app_id,
2199                                p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.num_of_mdep_data_types);
2200                         if (p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.mdep_role ==
2201                             BTA_HL_MDEP_ROLE_SOURCE)
2202                         {
2203                             p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SOURCE;
2204                         }
2205                         else if (p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.mdep_role ==
2206                                  BTA_HL_MDEP_ROLE_SINK)
2207                         {
2208                             p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SINK;
2209                         }
2210                         else
2211                         {
2212                             APPL_TRACE_ERROR("bta_hl_app_registration: Invalid Role %d",
2213                                             p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.mdep_role);
2214                             status = BTA_HL_STATUS_MDEP_CO_FAIL;
2215                             break;
2216                         }
2217                     }
2218                     else
2219                     {
2220                         APPL_TRACE_ERROR("bta_hl_app_registration: Cfg callout failed");
2221                         status = BTA_HL_STATUS_MDEP_CO_FAIL;
2222                         break;
2223                     }
2224                 }
2225                 else
2226                 {
2227                     APPL_TRACE_ERROR("bta_hl_app_registration: MCA_CreateDep failed");
2228                     status = BTA_HL_STATUS_MCAP_REG_FAIL;
2229                     break;
2230                 }
2231
2232             }
2233             p_acb->sup_feature.num_of_mdeps += num_of_mdeps;
2234             APPL_TRACE_DEBUG("num_of_mdeps %d", p_acb->sup_feature.num_of_mdeps);
2235
2236             if ((status == BTA_HL_STATUS_OK) &&
2237                 (p_acb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SOURCE))
2238             {
2239                 p_acb->sup_feature.advertize_source_sdp =
2240                 bta_hl_co_advrtise_source_sdp(app_id);
2241             }
2242
2243             if ((status == BTA_HL_STATUS_OK)&&
2244                 (!bta_hl_co_get_echo_config(app_id, &p_acb->sup_feature.echo_cfg)))
2245             {
2246                 status = BTA_HL_STATUS_ECHO_CO_FAIL;
2247             }
2248
2249             if ((status == BTA_HL_STATUS_OK)&&
2250                 (!bta_hl_co_load_mdl_config(app_id, BTA_HL_NUM_MDL_CFGS, &p_acb->mdl_cfg[0])))
2251             {
2252                 status = BTA_HL_STATUS_MDL_CFG_CO_FAIL;
2253             }
2254         }
2255         else
2256         {
2257             status = BTA_HL_STATUS_MDEP_CO_FAIL;
2258         }
2259     }
2260     else
2261     {
2262         for (i=1; i<BTA_HL_NUM_MDEPS; i++)
2263         {
2264             if (p_acb->sup_feature.mdep[i].ori_app_id == app_id)
2265             {
2266                 APPL_TRACE_DEBUG("Found index %", i);
2267
2268
2269                 if (MCA_DeleteDep((tMCA_HANDLE)p_acb->app_handle,
2270                                   (p_acb->sup_feature.mdep[i].mdep_id)) != MCA_SUCCESS)
2271                 {
2272                     APPL_TRACE_ERROR("Error deregistering");
2273                     status = BTA_HL_STATUS_MCAP_REG_FAIL;
2274                     return status;
2275                 }
2276                 memset(&p_acb->sup_feature.mdep[i], 0, sizeof(tBTA_HL_MDEP));
2277             }
2278         }
2279
2280
2281     }
2282
2283     if (status == BTA_HL_STATUS_OK)
2284     {
2285         /* Register/Update MDEP(s) in SDP Record */
2286         status = bta_hl_sdp_update(app_id);
2287     }
2288     /* else do cleanup */
2289
2290
2291     return status;
2292 }
2293
2294
2295 /*******************************************************************************
2296 **
2297 ** Function      bta_hl_app_registration
2298 **
2299 ** Description  This function registers an HDP application MCAP and DP
2300 **
2301 ** Returns      tBTA_HL_STATUS -registration status
2302 **
2303 *******************************************************************************/
2304 tBTA_HL_STATUS bta_hl_app_registration(UINT8 app_idx)
2305 {
2306     tBTA_HL_STATUS  status = BTA_HL_STATUS_OK;
2307     tBTA_HL_APP_CB  *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2308     tMCA_REG        reg;
2309     tMCA_CS         mca_cs;
2310     UINT8           i, num_of_mdeps;
2311     UINT8           mdep_counter = 0;
2312
2313 #if BTA_HL_DEBUG == TRUE
2314     APPL_TRACE_DEBUG("bta_hl_app_registration app_idx=%d", app_idx);
2315 #endif
2316
2317     reg.ctrl_psm = p_acb->ctrl_psm;
2318     reg.data_psm = p_acb->data_psm;
2319     reg.sec_mask = p_acb->sec_mask;
2320     reg.rsp_tout = BTA_HL_MCAP_RSP_TOUT;
2321
2322     if ( (p_acb->app_handle = (tBTA_HL_APP_HANDLE) MCA_Register(&reg, bta_hl_mcap_ctrl_cback))!=0)
2323     {
2324         mca_cs.type = MCA_TDEP_ECHO;
2325         mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
2326         mca_cs.p_data_cback = bta_hl_mcap_data_cback;
2327
2328         if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
2329                           &(p_acb->sup_feature.mdep[0].mdep_id),
2330                           &mca_cs) == MCA_SUCCESS)
2331         {
2332             if (p_acb->sup_feature.mdep[0].mdep_id != BTA_HL_ECHO_TEST_MDEP_ID)
2333             {
2334                 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2335                 APPL_TRACE_ERROR("BAD MDEP ID for echo test mdep_id=%d",
2336                                   p_acb->sup_feature.mdep[0].mdep_id );
2337             }
2338         }
2339         else
2340         {
2341             status = BTA_HL_STATUS_MCAP_REG_FAIL;
2342             APPL_TRACE_ERROR("MCA_CreateDep for echo test(mdep_id=0) failed");
2343         }
2344
2345
2346         if ((status == BTA_HL_STATUS_OK) &&
2347             bta_hl_co_get_num_of_mdep(p_acb->app_id, &num_of_mdeps))
2348         {
2349             p_acb->sup_feature.num_of_mdeps = num_of_mdeps+1;
2350
2351             for (i=1; i<p_acb->sup_feature.num_of_mdeps; i++)
2352             {
2353                 mca_cs.type = MCA_TDEP_DATA;
2354                 mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
2355                 mca_cs.p_data_cback = bta_hl_mcap_data_cback;
2356
2357                 if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
2358                                   &(p_acb->sup_feature.mdep[i].mdep_id), &mca_cs) == MCA_SUCCESS)
2359                 {
2360                     if (bta_hl_co_get_mdep_config(p_acb->app_id,
2361                                                   i,mdep_counter,
2362                                                   p_acb->sup_feature.mdep[i].mdep_id,
2363                                                   &p_acb->sup_feature.mdep[i].mdep_cfg))
2364                     {
2365                         if (p_acb->sup_feature.mdep[i].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
2366                         {
2367                             p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SOURCE;
2368                         }
2369                         else if (p_acb->sup_feature.mdep[i].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SINK)
2370                         {
2371                             p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SINK;
2372                         }
2373                         else
2374                         {
2375                             status = BTA_HL_STATUS_MDEP_CO_FAIL;
2376                             break;
2377                         }
2378                         p_acb->sup_feature.mdep[i].ori_app_id = p_acb->app_id;
2379                         APPL_TRACE_DEBUG("index %d ori_app_id %d", i,
2380                                           p_acb->sup_feature.mdep[i].ori_app_id);
2381                     }
2382                     else
2383                     {
2384                         status = BTA_HL_STATUS_MDEP_CO_FAIL;
2385                         break;
2386                     }
2387                 }
2388                 else
2389                 {
2390                     status = BTA_HL_STATUS_MCAP_REG_FAIL;
2391                     break;
2392                 }
2393             }
2394
2395
2396
2397             if ((status == BTA_HL_STATUS_OK) &&
2398                 (p_acb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SOURCE))
2399             {
2400                 /* this is a source only applciation */
2401                 p_acb->sup_feature.advertize_source_sdp =
2402                 bta_hl_co_advrtise_source_sdp(p_acb->app_id);
2403             }
2404
2405             if ((status == BTA_HL_STATUS_OK)&&
2406                 (!bta_hl_co_get_echo_config(p_acb->app_id, &p_acb->sup_feature.echo_cfg)))
2407             {
2408                 status = BTA_HL_STATUS_ECHO_CO_FAIL;
2409             }
2410
2411             if ((status == BTA_HL_STATUS_OK)&&
2412                 (!bta_hl_co_load_mdl_config(p_acb->app_id, BTA_HL_NUM_MDL_CFGS, &p_acb->mdl_cfg[0])))
2413             {
2414                 status = BTA_HL_STATUS_MDL_CFG_CO_FAIL;
2415             }
2416         }
2417         else
2418         {
2419             status = BTA_HL_STATUS_MDEP_CO_FAIL;
2420         }
2421     }
2422     else
2423     {
2424         status = BTA_HL_STATUS_MCAP_REG_FAIL;
2425     }
2426
2427     if (status == BTA_HL_STATUS_OK)
2428     {
2429         status = bta_hl_sdp_register(app_idx);
2430     }
2431
2432     return status;
2433 }
2434
2435
2436 /*******************************************************************************
2437 **
2438 ** Function         bta_hl_discard_data
2439 **
2440 ** Description  This function discard an HDP event
2441 **
2442 ** Returns     void
2443 **
2444 *******************************************************************************/
2445 void bta_hl_discard_data(UINT16 event, tBTA_HL_DATA *p_data)
2446 {
2447
2448 #if BTA_HL_DEBUG == TRUE
2449     APPL_TRACE_ERROR("BTA HL Discard event=%s",bta_hl_evt_code(event));
2450
2451 #endif
2452
2453     switch (event)
2454     {
2455         case BTA_HL_API_SEND_DATA_EVT:
2456             break;
2457
2458         case BTA_HL_MCA_RCV_DATA_EVT:
2459             osi_free_and_reset((void **)&p_data->mca_rcv_data_evt.p_pkt);
2460             break;
2461
2462         default:
2463             /*Nothing to free*/
2464             break;
2465     }
2466 }
2467
2468 /*******************************************************************************
2469 **
2470 ** Function         bta_hl_save_mdl_cfg
2471 **
2472 ** Description    This function saves the MDL configuration
2473 **
2474 ** Returns     void
2475 **
2476 *******************************************************************************/
2477 void bta_hl_save_mdl_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx )
2478 {
2479     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
2480     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2481     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2482     UINT8 mdl_cfg_idx;
2483     tBTA_HL_MDL_ID mdl_id;
2484     BOOLEAN      found=TRUE;
2485     tBTA_HL_MDL_CFG mdl_cfg;
2486     tBTA_HL_MDEP *p_mdep_cfg;
2487     tBTA_HL_L2CAP_CFG_INFO l2cap_cfg;
2488     UINT8 time_val = 0;
2489     mdl_id = p_dcb->mdl_id;
2490     if (!bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, mdl_id, &mdl_cfg_idx))
2491     {
2492         if (!bta_hl_find_avail_mdl_cfg_idx(app_idx, mcl_idx, &mdl_cfg_idx))
2493         {
2494             APPL_TRACE_ERROR("No space to save the MDL config");
2495             found= FALSE; /*no space available*/
2496         }
2497     }
2498
2499     if (found)
2500     {
2501         bta_hl_get_l2cap_cfg(p_dcb->mdl_handle, &l2cap_cfg);
2502         if (!bta_hl_get_cur_time(app_idx, &time_val ))
2503         {
2504             bta_hl_compact_mdl_cfg_time(app_idx,p_dcb->local_mdep_id);
2505             bta_hl_get_cur_time(app_idx, &time_val);
2506         }
2507         mdl_cfg.active = TRUE;
2508         mdl_cfg.time = time_val;
2509         mdl_cfg.mdl_id  = p_dcb->mdl_id;
2510         mdl_cfg.dch_mode = p_dcb->dch_mode;
2511         mdl_cfg.mtu = l2cap_cfg.mtu;
2512         mdl_cfg.fcs = l2cap_cfg.fcs;
2513
2514         bdcpy(mdl_cfg.peer_bd_addr, p_mcb->bd_addr);
2515         mdl_cfg.local_mdep_id= p_dcb->local_mdep_id;
2516         p_mdep_cfg = &p_acb->sup_feature.mdep[p_dcb->local_mdep_cfg_idx];
2517         mdl_cfg.local_mdep_role= p_mdep_cfg->mdep_cfg.mdep_role;
2518         memcpy(&p_acb->mdl_cfg[mdl_cfg_idx], &mdl_cfg, sizeof(tBTA_HL_MDL_CFG));
2519         bta_hl_co_save_mdl(mdl_cfg.local_mdep_id, mdl_cfg_idx, &mdl_cfg);
2520     }
2521
2522 #if BTA_HL_DEBUG == TRUE
2523     if (found)
2524     {
2525         if (p_dcb->mtu != l2cap_cfg.mtu)
2526         {
2527             APPL_TRACE_WARNING("MCAP and L2CAP peer mtu size out of sync from MCAP mtu=%d from l2cap mtu=%d",
2528                                 p_dcb->mtu, l2cap_cfg.mtu);
2529         }
2530         APPL_TRACE_DEBUG("bta_hl_save_mdl_cfg saved=%d", found);
2531         APPL_TRACE_DEBUG("Saved. L2cap cfg mdl_id=%d mtu=%d fcs=%d dch_mode=%d",
2532                           mdl_cfg.mdl_id, mdl_cfg.mtu, mdl_cfg.fcs,  mdl_cfg.dch_mode);
2533     }
2534 #endif
2535
2536
2537
2538 }
2539
2540 /*******************************************************************************
2541 **
2542 ** Function      bta_hl_set_dch_chan_cfg
2543 **
2544 ** Description    This function setups the L2CAP DCH channel configuration
2545 **
2546 ** Returns     void
2547 *******************************************************************************/
2548 void bta_hl_set_dch_chan_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,tBTA_HL_DATA *p_data)
2549 {
2550     tBTA_HL_APP_CB *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
2551     tBTA_HL_MDL_CB *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2552     UINT8 l2cap_mode = L2CAP_FCR_ERTM_MODE;
2553     tBTA_HL_SUP_FEATURE *p_sup_feature= &p_acb->sup_feature;
2554     UINT8 local_mdep_cfg_idx = p_dcb->local_mdep_cfg_idx;
2555
2556     switch (p_dcb->dch_oper)
2557     {
2558         case BTA_HL_DCH_OP_LOCAL_RECONNECT:
2559         case BTA_HL_DCH_OP_REMOTE_RECONNECT:
2560             if (p_dcb->dch_mode  == BTA_HL_DCH_MODE_STREAMING)
2561                 l2cap_mode = L2CAP_FCR_STREAM_MODE;
2562             break;
2563         case BTA_HL_DCH_OP_LOCAL_OPEN:
2564             if (p_data->mca_evt.mca_data.create_cfm.cfg == BTA_HL_DCH_CFG_STREAMING)
2565                 l2cap_mode = L2CAP_FCR_STREAM_MODE;
2566             break;
2567         case BTA_HL_DCH_OP_REMOTE_OPEN:
2568             if (p_dcb->local_cfg == BTA_HL_DCH_CFG_STREAMING )
2569                 l2cap_mode = L2CAP_FCR_STREAM_MODE;
2570             break;
2571         default:
2572             APPL_TRACE_ERROR("Invalid dch oper=%d for set dch chan cfg", p_dcb->dch_oper);
2573             break;
2574     }
2575     p_dcb->chnl_cfg.fcr_opt.mode        = l2cap_mode;
2576     p_dcb->chnl_cfg.fcr_opt.mps         = bta_hl_set_mps(p_dcb->max_rx_apdu_size);
2577     p_dcb->chnl_cfg.fcr_opt.tx_win_sz   = bta_hl_set_tx_win_size(p_dcb->max_rx_apdu_size,
2578                                                                  p_dcb->chnl_cfg.fcr_opt.mps);
2579     p_dcb->chnl_cfg.fcr_opt.max_transmit= BTA_HL_L2C_MAX_TRANSMIT;
2580     p_dcb->chnl_cfg.fcr_opt.rtrans_tout = BTA_HL_L2C_RTRANS_TOUT;
2581     p_dcb->chnl_cfg.fcr_opt.mon_tout    = BTA_HL_L2C_MON_TOUT;
2582
2583     p_dcb->chnl_cfg.user_rx_buf_size    = bta_hl_set_user_rx_buf_size(p_dcb->max_rx_apdu_size);
2584     p_dcb->chnl_cfg.user_tx_buf_size    = bta_hl_set_user_tx_buf_size(p_dcb->max_tx_apdu_size);
2585     p_dcb->chnl_cfg.fcr_rx_buf_size     = L2CAP_INVALID_ERM_BUF_SIZE;
2586     p_dcb->chnl_cfg.fcr_tx_buf_size     = L2CAP_INVALID_ERM_BUF_SIZE;
2587     p_dcb->chnl_cfg.data_mtu            = p_dcb->max_rx_apdu_size;
2588
2589     p_dcb->chnl_cfg.fcs = BTA_HL_MCA_NO_FCS;
2590     if (local_mdep_cfg_idx !=  BTA_HL_ECHO_TEST_MDEP_CFG_IDX)
2591     {
2592         if (p_sup_feature->mdep[local_mdep_cfg_idx].mdep_cfg.mdep_role ==
2593             BTA_HL_MDEP_ROLE_SOURCE)
2594         {
2595             p_dcb->chnl_cfg.fcs = BTA_HL_DEFAULT_SOURCE_FCS;
2596         }
2597     }
2598     else
2599     {
2600         p_dcb->chnl_cfg.fcs = BTA_HL_MCA_USE_FCS;
2601     }
2602
2603 #if BTA_HL_DEBUG == TRUE
2604     APPL_TRACE_DEBUG("L2CAP Params l2cap_mode[3-ERTM 4-STREAM]=%d", l2cap_mode);
2605     APPL_TRACE_DEBUG("Use FCS =%s mtu=%d", ((p_dcb->chnl_cfg.fcs & 1)?"YES":"NO"),
2606                       p_dcb->chnl_cfg.data_mtu);
2607     APPL_TRACE_DEBUG("tx_win_sz=%d, max_transmit=%d, rtrans_tout=%d, mon_tout=%d, mps=%d",
2608                       p_dcb->chnl_cfg.fcr_opt.tx_win_sz,
2609                       p_dcb->chnl_cfg.fcr_opt.max_transmit,
2610                       p_dcb->chnl_cfg.fcr_opt.rtrans_tout,
2611                       p_dcb->chnl_cfg.fcr_opt.mon_tout,
2612                       p_dcb->chnl_cfg.fcr_opt.mps);
2613
2614     APPL_TRACE_DEBUG("USER rx_buf_size=%d, tx_buf_size=%d, FCR rx_buf_size=%d, tx_buf_size=%d",
2615                       p_dcb->chnl_cfg.user_rx_buf_size,
2616                       p_dcb->chnl_cfg.user_tx_buf_size,
2617                       p_dcb->chnl_cfg.fcr_rx_buf_size,
2618                       p_dcb->chnl_cfg.fcr_tx_buf_size);
2619
2620 #endif
2621
2622
2623
2624
2625
2626
2627
2628
2629 }
2630
2631 /*******************************************************************************
2632 **
2633 ** Function      bta_hl_get_l2cap_cfg
2634 **
2635 ** Description    This function get the current L2CAP channel configuration
2636 **
2637 ** Returns     BOOLEAN - TRUE - operation is successful
2638 *******************************************************************************/
2639 BOOLEAN bta_hl_get_l2cap_cfg(tBTA_HL_MDL_HANDLE mdl_hnd, tBTA_HL_L2CAP_CFG_INFO *p_cfg)
2640 {
2641     BOOLEAN success = FALSE;
2642     UINT16 lcid;
2643     tL2CAP_CFG_INFO *p_our_cfg;
2644     tL2CAP_CH_CFG_BITS our_cfg_bits;
2645     tL2CAP_CFG_INFO *p_peer_cfg;
2646     tL2CAP_CH_CFG_BITS peer_cfg_bits;
2647
2648     lcid = MCA_GetL2CapChannel((tMCA_DL) mdl_hnd);
2649     if ( lcid &&
2650          L2CA_GetCurrentConfig(lcid, &p_our_cfg, &our_cfg_bits, &p_peer_cfg,
2651                                &peer_cfg_bits))
2652     {
2653         p_cfg->fcs = BTA_HL_MCA_NO_FCS;
2654         if (our_cfg_bits & L2CAP_CH_CFG_MASK_FCS)
2655         {
2656             p_cfg->fcs |= p_our_cfg->fcs;
2657         }
2658         else
2659         {
2660             p_cfg->fcs = BTA_HL_MCA_USE_FCS;
2661         }
2662
2663         if (p_cfg->fcs != BTA_HL_MCA_USE_FCS )
2664         {
2665             if (peer_cfg_bits & L2CAP_CH_CFG_MASK_FCS)
2666             {
2667                 p_cfg->fcs |= p_peer_cfg->fcs;
2668             }
2669             else
2670             {
2671                 p_cfg->fcs = BTA_HL_MCA_USE_FCS;
2672             }
2673         }
2674
2675         p_cfg->mtu =0;
2676         if (peer_cfg_bits & L2CAP_CH_CFG_MASK_MTU)
2677         {
2678             p_cfg->mtu = p_peer_cfg->mtu;
2679         }
2680         else
2681         {
2682             p_cfg->mtu = L2CAP_DEFAULT_MTU;
2683         }
2684         success = TRUE;
2685     }
2686     else
2687     {
2688       p_cfg->mtu = L2CAP_DEFAULT_MTU;
2689       p_cfg->fcs = BTA_HL_L2C_NO_FCS;
2690     }
2691
2692 #if BTA_HL_DEBUG == TRUE
2693     if (!success)
2694     {
2695         APPL_TRACE_DEBUG("bta_hl_get_l2cap_cfg success=%d mdl=%d lcid=%d", success, mdl_hnd, lcid);
2696         APPL_TRACE_DEBUG("l2cap mtu=%d fcs=%d", p_cfg->mtu, p_cfg->fcs);
2697     }
2698 #endif
2699
2700     return success;
2701 }
2702
2703 /*******************************************************************************
2704 **
2705 ** Function      bta_hl_validate_chan_cfg
2706 **
2707 ** Description    This function validates the L2CAP channel configuration
2708 **
2709 ** Returns     BOOLEAN - TRUE - validation is successful
2710 *******************************************************************************/
2711 BOOLEAN bta_hl_validate_chan_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx)
2712 {
2713     tBTA_HL_APP_CB *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
2714     tBTA_HL_MDL_CB *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2715     BOOLEAN success = FALSE;
2716     UINT8 mdl_cfg_idx = 0;
2717     tBTA_HL_L2CAP_CFG_INFO l2cap_cfg;
2718     BOOLEAN get_l2cap_result, get_mdl_result;
2719
2720     get_l2cap_result = bta_hl_get_l2cap_cfg(p_dcb->mdl_handle, &l2cap_cfg);
2721     get_mdl_result = bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, p_dcb->mdl_id, &mdl_cfg_idx);
2722
2723     if (get_l2cap_result && get_mdl_result)
2724     {
2725         if ((p_acb->mdl_cfg[mdl_cfg_idx].mtu <= l2cap_cfg.mtu) &&
2726             (p_acb->mdl_cfg[mdl_cfg_idx].fcs == l2cap_cfg.fcs) &&
2727             (p_acb->mdl_cfg[mdl_cfg_idx].dch_mode == p_dcb->dch_mode))
2728         {
2729             success = TRUE;
2730         }
2731     }
2732
2733
2734 #if BTA_HL_DEBUG == TRUE
2735
2736     if (p_dcb->mtu != l2cap_cfg.mtu)
2737     {
2738         APPL_TRACE_WARNING("MCAP and L2CAP peer mtu size out of sync from MCAP mtu=%d from l2cap mtu=%d",
2739                             p_dcb->mtu, l2cap_cfg.mtu);
2740     }
2741
2742     if (!success)
2743     {
2744         APPL_TRACE_DEBUG("bta_hl_validate_chan_cfg success=%d app_idx=%d mcl_idx=%d mdl_idx=%d",success, app_idx, mcl_idx, mdl_idx);
2745         APPL_TRACE_DEBUG("Cur. L2cap cfg mtu=%d fcs=%d dch_mode=%d", l2cap_cfg.mtu, l2cap_cfg.fcs, p_dcb->dch_mode);
2746         APPL_TRACE_DEBUG("From saved: L2cap cfg mtu=%d fcs=%d dch_mode=%d", p_acb->mdl_cfg[mdl_cfg_idx].mtu,
2747                           p_acb->mdl_cfg[mdl_cfg_idx].fcs , p_acb->mdl_cfg[mdl_cfg_idx].dch_mode);
2748     }
2749 #endif
2750
2751     return success;
2752 }
2753
2754
2755 /*******************************************************************************
2756 **
2757 ** Function      bta_hl_is_cong_on
2758 **
2759 ** Description    This function checks whether the congestion condition is on or not
2760 **
2761 ** Returns      BOOLEAN - TRUE DCH is congested
2762 **                        FALSE not congested
2763 **
2764 *******************************************************************************/
2765 BOOLEAN  bta_hl_is_cong_on(UINT8 app_id, BD_ADDR bd_addr, tBTA_HL_MDL_ID mdl_id)
2766
2767 {
2768     tBTA_HL_MDL_CB      *p_dcb;
2769     UINT8   app_idx = 0, mcl_idx, mdl_idx;
2770     BOOLEAN cong_status = TRUE;
2771
2772     if (bta_hl_find_app_idx(app_id, &app_idx))
2773     {
2774         if (bta_hl_find_mcl_idx(app_idx, bd_addr, &mcl_idx ))
2775         {
2776             if (bta_hl_find_mdl_idx(app_idx, mcl_idx, mdl_id, &mdl_idx ))
2777             {
2778                 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2779                 cong_status  = p_dcb->cong;
2780             }
2781         }
2782     }
2783
2784     return cong_status;
2785 }
2786
2787 /*******************************************************************************
2788 **
2789 ** Function      bta_hl_check_cch_close
2790 **
2791 ** Description   This function checks whether there is a pending CCH close request
2792 **               or not
2793 **
2794 ** Returns      void
2795 *******************************************************************************/
2796 void bta_hl_check_cch_close(UINT8 app_idx, UINT8 mcl_idx, tBTA_HL_DATA *p_data, BOOLEAN check_dch_setup )
2797 {
2798     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2799     tBTA_HL_MDL_CB      *p_dcb;
2800     UINT8               mdl_idx;
2801
2802 #if (BTA_HL_DEBUG == TRUE)
2803     APPL_TRACE_DEBUG("bta_hl_check_cch_close cch_close_dch_oper=%d",p_mcb->cch_close_dch_oper );
2804 #endif
2805
2806     if (p_mcb->cch_oper == BTA_HL_CCH_OP_LOCAL_CLOSE)
2807     {
2808         if (check_dch_setup && bta_hl_find_dch_setup_mdl_idx(app_idx, mcl_idx, &mdl_idx))
2809         {
2810             p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2811             if (!p_mcb->rsp_tout)
2812             {
2813                 p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_ABORT;
2814
2815                 if (!p_dcb->abort_oper)
2816                 {
2817                     p_dcb->abort_oper |= BTA_HL_ABORT_CCH_CLOSE_MASK;
2818                     bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_ABORT_EVT, p_data);
2819                 }
2820             }
2821             else
2822             {
2823                 p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_CLOSE;
2824                 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
2825             }
2826         }
2827         else if (bta_hl_find_an_active_mdl_idx(app_idx, mcl_idx,&mdl_idx))
2828         {
2829             p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_CLOSE;
2830             bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_EVT, p_data);
2831         }
2832         else
2833         {
2834             p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_NONE;
2835             bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_CLOSE_EVT, p_data);
2836         }
2837     }
2838 }
2839
2840 /*******************************************************************************
2841 **
2842 ** Function         bta_hl_clean_app
2843 **
2844 ** Description      Cleans up the HDP application resources and control block
2845 **
2846 ** Returns          void
2847 **
2848 *******************************************************************************/
2849 void bta_hl_clean_app(UINT8 app_idx)
2850 {
2851     tBTA_HL_APP_CB         *p_acb   = BTA_HL_GET_APP_CB_PTR(app_idx);
2852     int i, num_act_apps=0;
2853
2854 #if BTA_HL_DEBUG == TRUE
2855     APPL_TRACE_DEBUG("bta_hl_clean_app");
2856 #endif
2857     MCA_Deregister((tMCA_HANDLE)p_acb->app_handle);
2858
2859     if (p_acb->sdp_handle) SDP_DeleteRecord(p_acb->sdp_handle);
2860
2861     memset((void *) p_acb, 0, sizeof(tBTA_HL_APP_CB));
2862
2863     /* check any application is still active */
2864     for (i=0; i < BTA_HL_NUM_APPS ; i ++)
2865     {
2866         p_acb = BTA_HL_GET_APP_CB_PTR(i);
2867         if (p_acb->in_use) num_act_apps++;
2868     }
2869
2870     if (!num_act_apps)
2871     {
2872         bta_sys_remove_uuid(UUID_SERVCLASS_HDP_PROFILE);
2873     }
2874 }
2875
2876 /*******************************************************************************
2877 **
2878 ** Function      bta_hl_check_deregistration
2879 **
2880 ** Description   This function checks whether there is a pending deregistration
2881 **               request or not
2882 **
2883 ** Returns      void
2884 *******************************************************************************/
2885 void bta_hl_check_deregistration(UINT8 app_idx, tBTA_HL_DATA *p_data )
2886 {
2887     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
2888     tBTA_HL_MCL_CB      *p_mcb;
2889     UINT8               mcl_idx;
2890     tBTA_HL             evt_data;
2891
2892 #if (BTA_HL_DEBUG == TRUE)
2893     APPL_TRACE_DEBUG("bta_hl_check_deregistration");
2894 #endif
2895
2896     if (p_acb->deregistering)
2897     {
2898         if (bta_hl_find_an_in_use_mcl_idx(app_idx, &mcl_idx))
2899         {
2900             p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2901             if (p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_CLOSE)
2902             {
2903                 if (p_mcb->cch_state == BTA_HL_CCH_OPENING_ST)
2904                     p_mcb->force_close_local_cch_opening = TRUE;
2905                 p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_CLOSE;
2906                 APPL_TRACE_DEBUG("p_mcb->force_close_local_cch_opening=%d", p_mcb->force_close_local_cch_opening  );
2907                 bta_hl_check_cch_close(app_idx,mcl_idx,p_data, TRUE);
2908             }
2909         }
2910         else
2911         {
2912             /* all cchs are closed */
2913             evt_data.dereg_cfm.app_handle = p_acb->app_handle;
2914             evt_data.dereg_cfm.app_id = p_data->api_dereg.app_id;
2915             evt_data.dereg_cfm.status = BTA_HL_STATUS_OK;
2916             p_acb->p_cback(BTA_HL_DEREGISTER_CFM_EVT, (tBTA_HL *) &evt_data );
2917             bta_hl_clean_app(app_idx);
2918             bta_hl_check_disable(p_data);
2919         }
2920     }
2921 }
2922
2923
2924 /*******************************************************************************
2925 **
2926 ** Function      bta_hl_check_disable
2927 **
2928 ** Description   This function checks whether there is a pending disable
2929 **               request or not
2930 **
2931 ** Returns      void
2932 **
2933 *******************************************************************************/
2934 void bta_hl_check_disable(tBTA_HL_DATA *p_data )
2935 {
2936     tBTA_HL_CB          *p_cb= &bta_hl_cb;
2937     tBTA_HL_APP_CB      *p_acb;
2938     UINT8               app_idx;
2939     tBTA_HL_CTRL        evt_data;
2940
2941 #if (BTA_HL_DEBUG == TRUE)
2942     APPL_TRACE_DEBUG("bta_hl_check_disable");
2943 #endif
2944
2945     if (bta_hl_cb.disabling)
2946     {
2947         if (bta_hl_find_an_in_use_app_idx(&app_idx))
2948         {
2949             p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
2950             if (!p_acb->deregistering)
2951             {
2952                 p_acb->deregistering = TRUE;
2953                 bta_hl_check_deregistration(app_idx, p_data);
2954             }
2955         }
2956         else
2957         {
2958             /* all apps are deregistered */
2959             bta_sys_deregister(BTA_ID_HL);
2960             evt_data.disable_cfm.status = BTA_HL_STATUS_OK;
2961             if (p_cb->p_ctrl_cback) p_cb->p_ctrl_cback(BTA_HL_CTRL_DISABLE_CFM_EVT, (tBTA_HL_CTRL *) &evt_data);
2962             memset((void *) p_cb, 0, sizeof(tBTA_HL_CB));
2963         }
2964     }
2965 }
2966
2967 /*******************************************************************************
2968 **
2969 ** Function      bta_hl_build_abort_cfm
2970 **
2971 ** Description   This function builds the abort confirmation event data
2972 **
2973 ** Returns      None
2974 **
2975 *******************************************************************************/
2976 void  bta_hl_build_abort_cfm(tBTA_HL *p_evt_data,
2977                              tBTA_HL_APP_HANDLE app_handle,
2978                              tBTA_HL_MCL_HANDLE mcl_handle,
2979                              tBTA_HL_STATUS status)
2980 {
2981     p_evt_data->dch_abort_cfm.status = status;
2982     p_evt_data->dch_abort_cfm.mcl_handle = mcl_handle;
2983     p_evt_data->dch_abort_cfm.app_handle = app_handle;
2984 }
2985
2986 /*******************************************************************************
2987 **
2988 ** Function      bta_hl_build_abort_ind
2989 **
2990 ** Description   This function builds the abort indication event data
2991 **
2992 ** Returns      None
2993 **
2994 *******************************************************************************/
2995 void  bta_hl_build_abort_ind(tBTA_HL *p_evt_data,
2996                              tBTA_HL_APP_HANDLE app_handle,
2997                              tBTA_HL_MCL_HANDLE mcl_handle)
2998 {
2999     p_evt_data->dch_abort_ind.mcl_handle = mcl_handle;
3000     p_evt_data->dch_abort_ind.app_handle = app_handle;
3001 }
3002 /*******************************************************************************
3003 **
3004 ** Function      bta_hl_build_close_cfm
3005 **
3006 ** Description   This function builds the close confirmation event data
3007 **
3008 ** Returns      None
3009 **
3010 *******************************************************************************/
3011 void  bta_hl_build_dch_close_cfm(tBTA_HL *p_evt_data,
3012                                  tBTA_HL_APP_HANDLE app_handle,
3013                                  tBTA_HL_MCL_HANDLE mcl_handle,
3014                                  tBTA_HL_MDL_HANDLE mdl_handle,
3015                                  tBTA_HL_STATUS status)
3016 {
3017     p_evt_data->dch_close_cfm.status = status;
3018     p_evt_data->dch_close_cfm.mdl_handle = mdl_handle;
3019     p_evt_data->dch_close_cfm.mcl_handle = mcl_handle;
3020     p_evt_data->dch_close_cfm.app_handle = app_handle;
3021 }
3022
3023 /*******************************************************************************
3024 **
3025 ** Function      bta_hl_build_dch_close_ind
3026 **
3027 ** Description   This function builds the close indication event data
3028 **
3029 ** Returns      None
3030 **
3031 *******************************************************************************/
3032 void  bta_hl_build_dch_close_ind(tBTA_HL *p_evt_data,
3033                                  tBTA_HL_APP_HANDLE app_handle,
3034                                  tBTA_HL_MCL_HANDLE mcl_handle,
3035                                  tBTA_HL_MDL_HANDLE mdl_handle,
3036                                  BOOLEAN intentional)
3037 {
3038     p_evt_data->dch_close_ind.mdl_handle = mdl_handle;
3039     p_evt_data->dch_close_ind.mcl_handle = mcl_handle;
3040     p_evt_data->dch_close_ind.app_handle = app_handle;
3041     p_evt_data->dch_close_ind.intentional = intentional;
3042 }
3043
3044 /*******************************************************************************
3045 **
3046 ** Function      bta_hl_build_send_data_cfm
3047 **
3048 ** Description   This function builds the send data confirmation event data
3049 **
3050 ** Returns      None
3051 **
3052 *******************************************************************************/
3053 void  bta_hl_build_send_data_cfm(tBTA_HL *p_evt_data,
3054                                  tBTA_HL_APP_HANDLE app_handle,
3055                                  tBTA_HL_MCL_HANDLE mcl_handle,
3056                                  tBTA_HL_MDL_HANDLE mdl_handle,
3057                                  tBTA_HL_STATUS status )
3058 {
3059
3060     p_evt_data->dch_send_data_cfm.mdl_handle = mdl_handle;
3061     p_evt_data->dch_send_data_cfm.mcl_handle = mcl_handle;
3062     p_evt_data->dch_send_data_cfm.app_handle = app_handle;
3063     p_evt_data->dch_send_data_cfm.status = status;
3064 }
3065
3066 /*******************************************************************************
3067 **
3068 ** Function      bta_hl_build_rcv_data_ind
3069 **
3070 ** Description   This function builds the received data indication event data
3071 **
3072 ** Returns      None
3073 **
3074 *******************************************************************************/
3075 void  bta_hl_build_rcv_data_ind(tBTA_HL *p_evt_data,
3076                                 tBTA_HL_APP_HANDLE app_handle,
3077                                 tBTA_HL_MCL_HANDLE mcl_handle,
3078                                 tBTA_HL_MDL_HANDLE mdl_handle)
3079 {
3080     p_evt_data->dch_rcv_data_ind.mdl_handle = mdl_handle;
3081     p_evt_data->dch_rcv_data_ind.mcl_handle = mcl_handle;
3082     p_evt_data->dch_rcv_data_ind.app_handle = app_handle;
3083 }
3084
3085
3086 /*******************************************************************************
3087 **
3088 ** Function      bta_hl_build_cch_open_cfm
3089 **
3090 ** Description   This function builds the CCH open confirmation event data
3091 **
3092 ** Returns      None
3093 **
3094 *******************************************************************************/
3095 void  bta_hl_build_cch_open_cfm(tBTA_HL *p_evt_data,
3096                                 UINT8 app_id,
3097                                 tBTA_HL_APP_HANDLE app_handle,
3098                                 tBTA_HL_MCL_HANDLE mcl_handle,
3099                                 BD_ADDR bd_addr,
3100                                 tBTA_HL_STATUS status )
3101 {
3102     p_evt_data->cch_open_cfm.app_id = app_id;
3103     p_evt_data->cch_open_cfm.app_handle = app_handle;
3104     p_evt_data->cch_open_cfm.mcl_handle = mcl_handle;
3105     bdcpy(p_evt_data->cch_open_cfm.bd_addr, bd_addr);
3106     p_evt_data->cch_open_cfm.status = status;
3107     APPL_TRACE_DEBUG("bta_hl_build_cch_open_cfm: status=%d",status);
3108 }
3109
3110 /*******************************************************************************
3111 **
3112 ** Function      bta_hl_build_cch_open_ind
3113 **
3114 ** Description   This function builds the CCH open indication event data
3115 **
3116 ** Returns      None
3117 **
3118 *******************************************************************************/
3119 void  bta_hl_build_cch_open_ind(tBTA_HL *p_evt_data, tBTA_HL_APP_HANDLE app_handle,
3120                                 tBTA_HL_MCL_HANDLE mcl_handle,
3121                                 BD_ADDR bd_addr )
3122 {
3123
3124     p_evt_data->cch_open_ind.app_handle = app_handle;
3125     p_evt_data->cch_open_ind.mcl_handle = mcl_handle;
3126     bdcpy(p_evt_data->cch_open_ind.bd_addr, bd_addr);
3127 }
3128
3129 /*******************************************************************************
3130 **
3131 ** Function      bta_hl_build_cch_close_cfm
3132 **
3133 ** Description   This function builds the CCH close confirmation event data
3134 **
3135 ** Returns      None
3136 **
3137 *******************************************************************************/
3138 void  bta_hl_build_cch_close_cfm(tBTA_HL *p_evt_data,
3139                                  tBTA_HL_APP_HANDLE app_handle,
3140                                  tBTA_HL_MCL_HANDLE mcl_handle,
3141                                  tBTA_HL_STATUS status )
3142 {
3143     p_evt_data->cch_close_cfm.mcl_handle = mcl_handle;
3144     p_evt_data->cch_close_cfm.app_handle = app_handle;
3145     p_evt_data->cch_close_cfm.status = status;
3146 }
3147
3148
3149 /*******************************************************************************
3150 **
3151 ** Function      bta_hl_build_cch_close_ind
3152 **
3153 ** Description   This function builds the CCH colse indication event data
3154 **
3155 ** Returns      None
3156 **
3157 *******************************************************************************/
3158 void  bta_hl_build_cch_close_ind(tBTA_HL *p_evt_data,
3159                                  tBTA_HL_APP_HANDLE app_handle,
3160                                  tBTA_HL_MCL_HANDLE mcl_handle,
3161                                  BOOLEAN intentional)
3162 {
3163     p_evt_data->cch_close_ind.mcl_handle = mcl_handle;
3164     p_evt_data->cch_close_ind.app_handle = app_handle;
3165     p_evt_data->cch_close_ind.intentional = intentional;
3166 }
3167
3168 /*******************************************************************************
3169 **
3170 ** Function      bta_hl_build_dch_open_cfm
3171 **
3172 ** Description   This function builds the DCH open confirmation event data
3173 **
3174 ** Returns      None
3175 **
3176 *******************************************************************************/
3177 void  bta_hl_build_dch_open_cfm(tBTA_HL *p_evt_data,
3178                                 tBTA_HL_APP_HANDLE app_handle,
3179                                 tBTA_HL_MCL_HANDLE mcl_handle,
3180                                 tBTA_HL_MDL_HANDLE mdl_handle,
3181                                 tBTA_HL_MDEP_ID local_mdep_id,
3182                                 tBTA_HL_MDL_ID mdl_id,
3183                                 tBTA_HL_DCH_MODE dch_mode,
3184                                 BOOLEAN first_reliable,
3185                                 UINT16 mtu,
3186                                 tBTA_HL_STATUS status)
3187
3188 {
3189     p_evt_data->dch_open_cfm.mdl_handle = mdl_handle;
3190     p_evt_data->dch_open_cfm.mcl_handle = mcl_handle;
3191     p_evt_data->dch_open_cfm.app_handle = app_handle;
3192     p_evt_data->dch_open_cfm.local_mdep_id = local_mdep_id;
3193     p_evt_data->dch_open_cfm.mdl_id = mdl_id;
3194     p_evt_data->dch_open_cfm.dch_mode = dch_mode;
3195     p_evt_data->dch_open_cfm.first_reliable = first_reliable;
3196     p_evt_data->dch_open_cfm.mtu = mtu;
3197     p_evt_data->dch_open_cfm.status = status;
3198 }
3199
3200
3201 /*******************************************************************************
3202 **
3203 ** Function      bta_hl_build_sdp_query_cfm
3204 **
3205 ** Description   This function builds the SDP query indication event data
3206 **
3207 ** Returns      None
3208 **
3209 *******************************************************************************/
3210 void  bta_hl_build_sdp_query_cfm(tBTA_HL *p_evt_data,
3211                                  UINT8 app_id,
3212                                  tBTA_HL_APP_HANDLE app_handle,
3213                                  BD_ADDR bd_addr,
3214                                  tBTA_HL_SDP *p_sdp,
3215                                  tBTA_HL_STATUS status)
3216
3217 {
3218     APPL_TRACE_DEBUG("bta_hl_build_sdp_query_cfm: app_id = %d, app_handle=%d",
3219                         app_id,app_handle);
3220     p_evt_data->sdp_query_cfm.app_id = app_id;
3221     p_evt_data->sdp_query_cfm.app_handle = app_handle;
3222     bdcpy(p_evt_data->sdp_query_cfm.bd_addr, bd_addr);
3223     p_evt_data->sdp_query_cfm.p_sdp = p_sdp;
3224     p_evt_data->sdp_query_cfm.status = status;
3225 }
3226
3227
3228 /*******************************************************************************
3229 **
3230 ** Function      bta_hl_build_delete_mdl_cfm
3231 **
3232 ** Description   This function builds the delete MDL confirmation event data
3233 **
3234 ** Returns      None
3235 **
3236 *******************************************************************************/
3237 void  bta_hl_build_delete_mdl_cfm(tBTA_HL *p_evt_data,
3238                                   tBTA_HL_APP_HANDLE app_handle,
3239                                   tBTA_HL_MCL_HANDLE mcl_handle,
3240                                   tBTA_HL_MDL_ID mdl_id,
3241                                   tBTA_HL_STATUS status)
3242
3243 {
3244     p_evt_data->delete_mdl_cfm.mcl_handle = mcl_handle;
3245     p_evt_data->delete_mdl_cfm.app_handle = app_handle;
3246     p_evt_data->delete_mdl_cfm.mdl_id = mdl_id;
3247     p_evt_data->delete_mdl_cfm.status = status;
3248 }
3249
3250 /*******************************************************************************
3251 **
3252 ** Function      bta_hl_build_echo_test_cfm
3253 **
3254 ** Description   This function builds the echo test confirmation event data
3255 **
3256 ** Returns      None
3257 **
3258 *******************************************************************************/
3259 void  bta_hl_build_echo_test_cfm(tBTA_HL *p_evt_data,
3260                                  tBTA_HL_APP_HANDLE app_handle,
3261                                  tBTA_HL_MCL_HANDLE mcl_handle,
3262                                  tBTA_HL_STATUS status )
3263 {
3264     p_evt_data->echo_test_cfm.mcl_handle = mcl_handle;
3265     p_evt_data->echo_test_cfm.app_handle = app_handle;
3266     p_evt_data->echo_test_cfm.status = status;
3267 }
3268
3269
3270 /*****************************************************************************
3271 **  Debug Functions
3272 *****************************************************************************/
3273 #if (BTA_HL_DEBUG == TRUE)
3274
3275 /*******************************************************************************
3276 **
3277 ** Function         bta_hl_status_code
3278 **
3279 ** Description      get the status string pointer
3280 **
3281 ** Returns          char * - status string pointer
3282 **
3283 *******************************************************************************/
3284 char *bta_hl_status_code(tBTA_HL_STATUS status)
3285 {
3286     switch (status)
3287     {
3288         case BTA_HL_STATUS_OK:
3289             return "BTA_HL_STATUS_OK";
3290         case BTA_HL_STATUS_FAIL:
3291             return "BTA_HL_STATUS_FAIL";
3292         case BTA_HL_STATUS_ABORTED:
3293             return "BTA_HL_STATUS_ABORTED";
3294         case BTA_HL_STATUS_NO_RESOURCE:
3295             return "BTA_HL_STATUS_NO_RESOURCE";
3296         case BTA_HL_STATUS_LAST_ITEM:
3297             return "BTA_HL_STATUS_LAST_ITEM";
3298         case BTA_HL_STATUS_DUPLICATE_APP_ID:
3299             return "BTA_HL_STATUS_DUPLICATE_APP_ID";
3300         case BTA_HL_STATUS_INVALID_APP_HANDLE:
3301             return "BTA_HL_STATUS_INVALID_APP_HANDLE";
3302         case BTA_HL_STATUS_INVALID_MCL_HANDLE:
3303             return "BTA_HL_STATUS_INVALID_MCL_HANDLE";
3304         case BTA_HL_STATUS_MCAP_REG_FAIL:
3305             return "BTA_HL_STATUS_MCAP_REG_FAIL";
3306         case BTA_HL_STATUS_MDEP_CO_FAIL:
3307             return "BTA_HL_STATUS_MDEP_CO_FAIL";
3308         case BTA_HL_STATUS_ECHO_CO_FAIL:
3309             return "BTA_HL_STATUS_ECHO_CO_FAIL";
3310         case BTA_HL_STATUS_MDL_CFG_CO_FAIL:
3311             return "BTA_HL_STATUS_MDL_CFG_CO_FAIL";
3312         case BTA_HL_STATUS_SDP_NO_RESOURCE:
3313             return "BTA_HL_STATUS_SDP_NO_RESOURCE";
3314         case BTA_HL_STATUS_SDP_FAIL:
3315             return "BTA_HL_STATUS_SDP_FAIL";
3316         case BTA_HL_STATUS_NO_CCH:
3317             return "BTA_HL_STATUS_NO_CCH";
3318         case BTA_HL_STATUS_NO_MCL:
3319             return "BTA_HL_STATUS_NO_MCL";
3320
3321         case BTA_HL_STATUS_NO_FIRST_RELIABLE:
3322             return "BTA_HL_STATUS_NO_FIRST_RELIABLE";
3323         case BTA_HL_STATUS_INVALID_DCH_CFG:
3324             return "BTA_HL_STATUS_INVALID_DCH_CFG";
3325         case BTA_HL_STATUS_INVALID_BD_ADDR:
3326             return "BTA_HL_STATUS_INVALID_BD_ADDR";
3327         case BTA_HL_STATUS_INVALID_RECONNECT_CFG:
3328             return "BTA_HL_STATUS_INVALID_RECONNECT_CFG";
3329         case BTA_HL_STATUS_ECHO_TEST_BUSY:
3330             return "BTA_HL_STATUS_ECHO_TEST_BUSY";
3331         case BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID:
3332             return "BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID";
3333         case BTA_HL_STATUS_INVALID_MDL_ID:
3334             return "BTA_HL_STATUS_INVALID_MDL_ID";
3335         case BTA_HL_STATUS_NO_MDL_ID_FOUND:
3336             return "BTA_HL_STATUS_NO_MDL_ID_FOUND";
3337         case BTA_HL_STATUS_DCH_BUSY:
3338             return "BTA_HL_STATUS_DCH_BUSY";
3339         default:
3340             return "Unknown status code";
3341     }
3342 }
3343 /*******************************************************************************
3344 **
3345 ** Function         bta_hl_evt_code
3346 **
3347 ** Description      Maps HL event code to the corresponding event string
3348 **
3349 ** Returns          string pointer for the associated event name
3350 **
3351 *******************************************************************************/
3352 char *bta_hl_evt_code(tBTA_HL_INT_EVT evt_code)
3353 {
3354     switch (evt_code)
3355     {
3356         case BTA_HL_CCH_OPEN_EVT:
3357             return "BTA_HL_CCH_OPEN_EVT";
3358         case BTA_HL_CCH_SDP_OK_EVT:
3359             return "BTA_HL_CCH_SDP_OK_EVT";
3360         case BTA_HL_CCH_SDP_FAIL_EVT:
3361             return "BTA_HL_CCH_SDP_FAIL_EVT";
3362         case BTA_HL_MCA_CONNECT_IND_EVT:
3363             return "BTA_HL_MCA_CONNECT_IND_EVT";
3364         case BTA_HL_MCA_DISCONNECT_IND_EVT:
3365             return "BTA_HL_MCA_DISCONNECT_IND_EVT";
3366
3367         case BTA_HL_CCH_CLOSE_EVT:
3368             return "BTA_HL_CCH_CLOSE_EVT";
3369         case BTA_HL_CCH_CLOSE_CMPL_EVT:
3370             return "BTA_HL_CCH_CLOSE_CMPL_EVT";
3371         case BTA_HL_DCH_OPEN_EVT:
3372             return "BTA_HL_DCH_OPEN_EVT";
3373         case BTA_HL_MCA_CREATE_IND_EVT:
3374             return "BTA_HL_MCA_CREATE_IND_EVT";
3375         case BTA_HL_MCA_CREATE_CFM_EVT:
3376             return "BTA_HL_MCA_CREATE_CFM_EVT";
3377         case BTA_HL_MCA_OPEN_IND_EVT:
3378             return "BTA_HL_MCA_OPEN_IND_EVT";
3379         case BTA_HL_MCA_OPEN_CFM_EVT:
3380             return "BTA_HL_MCA_OPEN_CFM_EVT";
3381         case BTA_HL_DCH_CLOSE_EVT:
3382             return "BTA_HL_DCH_CLOSE_EVT";
3383         case BTA_HL_MCA_CLOSE_IND_EVT:
3384             return "BTA_HL_MCA_CLOSE_IND_EVT";
3385         case BTA_HL_MCA_CLOSE_CFM_EVT:
3386             return "BTA_HL_MCA_CLOSE_CFM_EVT";
3387         case BTA_HL_API_SEND_DATA_EVT:
3388             return "BTA_HL_API_SEND_DATA_EVT";
3389         case BTA_HL_MCA_RCV_DATA_EVT:
3390             return "BTA_HL_MCA_RCV_DATA_EVT";
3391         case BTA_HL_DCH_CLOSE_CMPL_EVT:
3392             return "BTA_HL_DCH_CLOSE_CMPL_EVT";
3393
3394         case BTA_HL_API_ENABLE_EVT:
3395             return "BTA_HL_API_ENABLE_EVT";
3396         case BTA_HL_API_DISABLE_EVT:
3397             return "BTA_HL_API_DISABLE_EVT";
3398         case BTA_HL_API_UPDATE_EVT:
3399              return "BTA_HL_API_UPDATE_EVT";
3400         case BTA_HL_API_REGISTER_EVT:
3401             return "BTA_HL_API_REGISTER_EVT";
3402         case BTA_HL_API_DEREGISTER_EVT:
3403             return "BTA_HL_API_DEREGISTER_EVT";
3404
3405         case BTA_HL_API_CCH_OPEN_EVT:
3406             return "BTA_HL_API_CCH_OPEN_EVT";
3407
3408         case BTA_HL_API_CCH_CLOSE_EVT:
3409             return "BTA_HL_API_CCH_CLOSE_EVT";
3410         case BTA_HL_API_DCH_OPEN_EVT:
3411             return "BTA_HL_API_DCH_OPEN_EVT";
3412
3413         case BTA_HL_API_DCH_RECONNECT_EVT:
3414             return "BTA_HL_API_DCH_RECONNECT_EVT";
3415         case BTA_HL_API_DCH_CLOSE_EVT:
3416             return "BTA_HL_API_DCH_CLOSE_EVT";
3417         case BTA_HL_API_DELETE_MDL_EVT:
3418             return "BTA_HL_API_DELETE_MDL_EVT";
3419         case BTA_HL_API_DCH_ABORT_EVT:
3420             return "BTA_HL_API_DCH_ABORT_EVT";
3421
3422         case BTA_HL_DCH_RECONNECT_EVT:
3423             return "BTA_HL_DCH_RECONNECT_EVT";
3424         case BTA_HL_DCH_SDP_INIT_EVT:
3425             return "BTA_HL_DCH_SDP_INIT_EVT";
3426         case BTA_HL_DCH_SDP_FAIL_EVT:
3427             return "BTA_HL_DCH_SDP_FAIL_EVT";
3428         case BTA_HL_API_DCH_ECHO_TEST_EVT:
3429             return "BTA_HL_API_DCH_ECHO_TEST_EVT";
3430         case BTA_HL_DCH_CLOSE_ECHO_TEST_EVT:
3431             return "BTA_HL_DCH_CLOSE_ECHO_TEST_EVT";
3432         case BTA_HL_MCA_RECONNECT_IND_EVT:
3433             return "BTA_HL_MCA_RECONNECT_IND_EVT";
3434         case BTA_HL_MCA_RECONNECT_CFM_EVT:
3435             return "BTA_HL_MCA_RECONNECT_CFM_EVT";
3436         case BTA_HL_API_DCH_CREATE_RSP_EVT:
3437             return "BTA_HL_API_DCH_CREATE_RSP_EVT";
3438         case BTA_HL_DCH_ABORT_EVT:
3439             return "BTA_HL_DCH_ABORT_EVT";
3440         case BTA_HL_MCA_ABORT_IND_EVT:
3441             return "BTA_HL_MCA_ABORT_IND_EVT";
3442         case BTA_HL_MCA_ABORT_CFM_EVT:
3443             return "BTA_HL_MCA_ABORT_CFM_EVT";
3444         case BTA_HL_MCA_DELETE_IND_EVT:
3445             return "BTA_HL_MCA_DELETE_IND_EVT";
3446         case BTA_HL_MCA_DELETE_CFM_EVT:
3447             return "BTA_HL_MCA_DELETE_CFM_EVT";
3448         case BTA_HL_MCA_CONG_CHG_EVT:
3449             return "BTA_HL_MCA_CONG_CHG_EVT";
3450         case BTA_HL_CI_GET_TX_DATA_EVT:
3451             return "BTA_HL_CI_GET_TX_DATA_EVT";
3452         case BTA_HL_CI_PUT_RX_DATA_EVT:
3453             return "BTA_HL_CI_PUT_RX_DATA_EVT";
3454         case BTA_HL_CI_GET_ECHO_DATA_EVT:
3455             return "BTA_HL_CI_GET_ECHO_DATA_EVT";
3456         case BTA_HL_DCH_ECHO_TEST_EVT:
3457             return "BTA_HL_DCH_ECHO_TEST_EVT";
3458         case BTA_HL_CI_PUT_ECHO_DATA_EVT:
3459             return "BTA_HL_CI_PUT_ECHO_DATA_EVT";
3460         case BTA_HL_API_SDP_QUERY_EVT:
3461             return "BTA_HL_API_SDP_QUERY_EVT";
3462         case BTA_HL_SDP_QUERY_OK_EVT:
3463             return "BTA_HL_SDP_QUERY_OK_EVT";
3464         case BTA_HL_SDP_QUERY_FAIL_EVT:
3465             return "BTA_HL_SDP_QUERY_FAIL_EVT";
3466         case BTA_HL_MCA_RSP_TOUT_IND_EVT:
3467             return "BTA_HL_MCA_RSP_TOUT_IND_EVT";
3468
3469         default:
3470             return "Unknown HL event code";
3471     }
3472 }
3473
3474 #endif  /* Debug Functions */
3475 #endif // HL_INCLUDED
3476
3477
3478
3479
3480
3481
3482
3483