Home | History | Annotate | Download | only in hl
      1 /******************************************************************************
      2  *
      3  *  Copyright (C) 2003-2012 Broadcom Corporation
      4  *
      5  *  Licensed under the Apache License, Version 2.0 (the "License");
      6  *  you may not use this file except in compliance with the License.
      7  *  You may obtain a copy of the License at:
      8  *
      9  *  http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  *  Unless required by applicable law or agreed to in writing, software
     12  *  distributed under the License is distributed on an "AS IS" BASIS,
     13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  *  See the License for the specific language governing permissions and
     15  *  limitations under the License.
     16  *
     17  ******************************************************************************/
     18 
     19 /******************************************************************************
     20  *
     21  *  This file contains the HeaLth device profile (HL) action functions for
     22  *  the state machine.
     23  *
     24  ******************************************************************************/
     25 
     26 #include <string.h>
     27 
     28 #include "bt_target.h"
     29 #if defined(HL_INCLUDED) && (HL_INCLUDED == TRUE)
     30 
     31 #include "gki.h"
     32 #include "sdp_api.h"
     33 #include "bta_sys.h"
     34 #include "port_api.h"
     35 #include "sdp_api.h"
     36 #include "bta_hl_api.h"
     37 #include "bta_hl_int.h"
     38 #include "utl.h"
     39 #include "bd.h"
     40 #include "mca_defs.h"
     41 #include "mca_api.h"
     42 
     43 /*****************************************************************************
     44 **  Local Function prototypes
     45 *****************************************************************************/
     46 #if (BTA_HL_DEBUG == TRUE && BT_TRACE_VERBOSE == TRUE)
     47 static char *bta_hl_mcap_evt_code(UINT8 evt_code);
     48 static char *bta_hl_dch_oper_code(tBTA_HL_DCH_OPER oper_code);
     49 static char *bta_hl_cback_evt_code(UINT8 evt_code);
     50 #endif
     51 static void bta_hl_sdp_cback(UINT8 sdp_op, UINT8 app_idx, UINT8 mcl_idx,
     52                              UINT8 mdl_idx, UINT16 status);
     53 static void bta_hl_sdp_cback0(UINT16 status);
     54 static void bta_hl_sdp_cback1(UINT16 status);
     55 static void bta_hl_sdp_cback2(UINT16 status);
     56 static void bta_hl_sdp_cback3(UINT16 status);
     57 static void bta_hl_sdp_cback4(UINT16 status);
     58 static void bta_hl_sdp_cback5(UINT16 status);
     59 static void bta_hl_sdp_cback6(UINT16 status);
     60 
     61 
     62 static tSDP_DISC_CMPL_CB * const bta_hl_sdp_cback_arr[] =
     63 {
     64     bta_hl_sdp_cback0,
     65     bta_hl_sdp_cback1,
     66     bta_hl_sdp_cback2,
     67     bta_hl_sdp_cback3,
     68     bta_hl_sdp_cback4,
     69     bta_hl_sdp_cback5,
     70     bta_hl_sdp_cback6
     71 };
     72 
     73 
     74 
     75 /*******************************************************************************
     76 **
     77 ** Function         bta_hl_dch_mca_cong_change
     78 **
     79 ** Description      Action routine for processing congestion change notification
     80 **
     81 ** Returns          void
     82 **
     83 *******************************************************************************/
     84 void bta_hl_dch_mca_cong_change(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
     85                                 tBTA_HL_DATA *p_data)
     86 {
     87     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
     88     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
     89     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
     90     tMCA_CONG_CHG       *p_cong_chg = &p_data->mca_evt.mca_data.cong_chg;
     91     tBTA_HL             evt_data;
     92 
     93 #if (BTA_HL_DEBUG == TRUE)
     94     APPL_TRACE_DEBUG2("bta_hl_dch_mca_cong_change mdl_id=%d cong=%d",
     95                       p_cong_chg->mdl_id,
     96                       p_cong_chg->cong);
     97 #endif
     98     evt_data.dch_cong_ind.cong          =
     99     p_dcb->cong                         = p_cong_chg->cong;
    100     evt_data.dch_cong_ind.mdl_handle    = p_dcb->mdl_handle;
    101     evt_data.dch_cong_ind.mcl_handle    = p_mcb->mcl_handle;
    102     evt_data.dch_cong_ind.app_handle    = p_acb->app_handle;
    103 
    104     p_acb->p_cback(BTA_HL_CONG_CHG_IND_EVT ,(tBTA_HL *) &evt_data );
    105 }
    106 
    107 
    108 
    109 /*******************************************************************************
    110 **
    111 ** Function         bta_hl_dch_echo_test
    112 **
    113 ** Description      Action routine for processing echo test request
    114 **
    115 ** Returns          void
    116 **
    117 *******************************************************************************/
    118 void bta_hl_dch_echo_test(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
    119                           tBTA_HL_DATA *p_data)
    120 {
    121     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
    122     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
    123     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
    124 
    125 #if (BTA_HL_DEBUG == TRUE)
    126     APPL_TRACE_DEBUG0("bta_hl_dch_echo_test");
    127 #endif
    128 
    129     p_dcb->echo_oper = BTA_HL_ECHO_OP_CI_GET_ECHO_DATA;
    130     p_dcb->cout_oper |= BTA_HL_CO_GET_ECHO_DATA_MASK;
    131 
    132     bta_hl_co_get_echo_data(p_acb->app_id, p_mcb->mcl_handle,
    133                             p_dcb->p_echo_tx_pkt->len,
    134                             BTA_HL_GET_BUF_PTR(p_dcb->p_echo_tx_pkt),
    135                             BTA_HL_CI_GET_ECHO_DATA_EVT);
    136 
    137 }
    138 /*******************************************************************************
    139 **
    140 ** Function         bta_hl_dch_sdp_init
    141 **
    142 ** Description      Action routine for processing DCH SDP initiation
    143 **
    144 ** Returns          void
    145 **
    146 *******************************************************************************/
    147 void bta_hl_dch_sdp_init(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
    148                          tBTA_HL_DATA *p_data)
    149 {
    150     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
    151     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
    152 
    153 #if (BTA_HL_DEBUG == TRUE)
    154     APPL_TRACE_DEBUG0("bta_hl_dch_sdp_init");
    155 #endif
    156     if ( p_mcb->sdp_oper == BTA_HL_SDP_OP_NONE)
    157     {
    158         p_mcb->sdp_mdl_idx = mdl_idx;
    159         if (p_dcb->dch_oper == BTA_HL_DCH_OP_LOCAL_OPEN )
    160         {
    161             p_mcb->sdp_oper = BTA_HL_SDP_OP_DCH_OPEN_INIT;
    162 
    163         }
    164         else
    165         {
    166             p_mcb->sdp_oper = BTA_HL_SDP_OP_DCH_RECONNECT_INIT;
    167         }
    168 
    169         if (bta_hl_init_sdp(p_mcb->sdp_oper, app_idx, mcl_idx, mdl_idx) != BTA_HL_STATUS_OK)
    170         {
    171             APPL_TRACE_ERROR0("SDP INIT failed");
    172             p_mcb->sdp_oper = BTA_HL_SDP_OP_NONE;
    173             bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_SDP_FAIL_EVT, p_data);
    174         }
    175     }
    176     else
    177     {
    178         APPL_TRACE_ERROR0("SDP in use");
    179         bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_SDP_FAIL_EVT, p_data);
    180     }
    181 }
    182 
    183 
    184 /*******************************************************************************
    185 **
    186 ** Function         bta_hl_dch_close_echo_test
    187 **
    188 ** Description      Action routine for processing the closing of echo test
    189 **
    190 ** Returns          void
    191 **
    192 *******************************************************************************/
    193 void bta_hl_dch_close_echo_test(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
    194                                 tBTA_HL_DATA *p_data)
    195 {
    196     tBTA_HL_MDL_CB          *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
    197 
    198 #if (BTA_HL_DEBUG == TRUE)
    199     APPL_TRACE_DEBUG0("bta_hl_dch_close_echo_test");
    200 #endif
    201 
    202     switch (p_dcb->echo_oper)
    203     {
    204         case BTA_HL_ECHO_OP_DCH_CLOSE_CFM:
    205         case BTA_HL_ECHO_OP_OPEN_IND:
    206         case BTA_HL_ECHO_OP_ECHO_PKT:
    207             p_dcb->dch_oper = BTA_HL_DCH_OP_LOCAL_CLOSE_ECHO_TEST;
    208             break;
    209         case BTA_HL_ECHO_OP_MDL_CREATE_CFM:
    210         case BTA_HL_ECHO_OP_DCH_OPEN_CFM:
    211         case BTA_HL_ECHO_OP_LOOP_BACK:
    212         default:
    213             break;
    214     }
    215 
    216     if (MCA_CloseReq((tMCA_DL) p_dcb->mdl_handle)!= MCA_SUCCESS)
    217     {
    218         bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
    219     }
    220 }
    221 
    222 
    223 /*******************************************************************************
    224 **
    225 ** Function         bta_hl_dch_mca_rcv_data
    226 **
    227 ** Description      Action routine for processing the received data
    228 **
    229 ** Returns          void
    230 **
    231 *******************************************************************************/
    232 void bta_hl_dch_mca_rcv_data(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
    233                              tBTA_HL_DATA *p_data)
    234 {
    235     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
    236     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
    237     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
    238 
    239 #if (BTA_HL_DEBUG == TRUE)
    240     APPL_TRACE_DEBUG0("bta_hl_dch_mca_rcv_data");
    241 #endif
    242 
    243     if (p_dcb->local_mdep_id == BTA_HL_ECHO_TEST_MDEP_ID)
    244     {
    245         switch ( p_dcb->echo_oper)
    246         {
    247             case  BTA_HL_ECHO_OP_ECHO_PKT:
    248 
    249                 if (MCA_WriteReq((tMCA_DL) p_dcb->mdl_handle, p_data->mca_rcv_data_evt.p_pkt) != MCA_SUCCESS)
    250                 {
    251                     utl_freebuf((void **) &p_data->mca_rcv_data_evt.p_pkt);
    252                     bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_ECHO_TEST_EVT, p_data);
    253                 }
    254                 break;
    255             case BTA_HL_ECHO_OP_LOOP_BACK:
    256 
    257                 p_dcb->p_echo_rx_pkt = p_data->mca_rcv_data_evt.p_pkt;
    258                 p_dcb->echo_oper = BTA_HL_ECHO_OP_CI_PUT_ECHO_DATA;
    259                 p_dcb->cout_oper |= BTA_HL_CO_PUT_ECHO_DATA_MASK;
    260                 p_dcb->ci_put_echo_data_status = BTA_HL_STATUS_FAIL;
    261 
    262                 bta_hl_co_put_echo_data(p_acb->app_id, p_mcb->mcl_handle,
    263                                         p_dcb->p_echo_rx_pkt->len,
    264                                         BTA_HL_GET_BUF_PTR(p_dcb->p_echo_rx_pkt),
    265                                         BTA_HL_CI_PUT_ECHO_DATA_EVT);
    266                 break;
    267             default:
    268                 APPL_TRACE_ERROR1("Unknonw echo_oper=%d",p_dcb->echo_oper);
    269                 break;
    270         }
    271 
    272     }
    273     else
    274     {
    275         p_dcb->cout_oper |= BTA_HL_CO_PUT_RX_DATA_MASK;
    276         p_dcb->p_rx_pkt = p_data->mca_rcv_data_evt.p_pkt;
    277 
    278         bta_hl_co_put_rx_data(p_acb->app_id, p_dcb->mdl_handle,
    279                               p_dcb->p_rx_pkt->len,
    280                               BTA_HL_GET_BUF_PTR(p_dcb->p_rx_pkt),
    281                               BTA_HL_CI_PUT_RX_DATA_EVT);
    282 
    283 
    284     }
    285 }
    286 
    287 
    288 /*******************************************************************************
    289 **
    290 ** Function         bta_hl_dch_ci_put_echo_data
    291 **
    292 ** Description      Action routine for processing the call-in of the
    293 **                  put echo data event
    294 **
    295 ** Returns          void
    296 **
    297 *******************************************************************************/
    298 void bta_hl_dch_ci_put_echo_data(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
    299                                  tBTA_HL_DATA *p_data)
    300 {
    301     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
    302 
    303 #if (BTA_HL_DEBUG == TRUE)
    304     APPL_TRACE_DEBUG0("bta_hl_dch_ci_put_echo_data");
    305 #endif
    306 
    307     p_dcb->cout_oper &= ~BTA_HL_CO_PUT_ECHO_DATA_MASK;
    308     utl_freebuf((void **) &p_dcb->p_echo_rx_pkt);
    309     p_dcb->ci_put_echo_data_status = p_data->ci_get_put_echo_data.status;
    310 
    311     p_dcb->echo_oper = BTA_HL_ECHO_OP_DCH_CLOSE_CFM;
    312     bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_ECHO_TEST_EVT, p_data);
    313 }
    314 
    315 
    316 
    317 /*******************************************************************************
    318 **
    319 ** Function         bta_hl_dch_ci_get_echo_data
    320 **
    321 ** Description      Action routine for processing the call-in of the
    322 **                  get echo data event
    323 **
    324 ** Returns          void
    325 **
    326 *******************************************************************************/
    327 void bta_hl_dch_ci_get_echo_data(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
    328                                  tBTA_HL_DATA *p_data)
    329 {
    330     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
    331     tBTA_HL_STATUS      status;
    332 
    333 #if (BTA_HL_DEBUG == TRUE)
    334     APPL_TRACE_DEBUG0("bta_hl_dch_ci_get_echo_data");
    335 #endif
    336 
    337     p_dcb->cout_oper &= ~BTA_HL_CO_GET_ECHO_DATA_MASK;
    338 
    339     if (!p_dcb->abort_oper)
    340     {
    341         status = p_data->ci_get_put_echo_data.status;
    342         if (status == BTA_HL_STATUS_OK)
    343         {
    344             p_dcb->echo_oper = BTA_HL_ECHO_OP_MDL_CREATE_CFM;
    345             bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_OPEN_EVT, p_data);
    346         }
    347         else
    348         {
    349             bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
    350         }
    351     }
    352     else
    353     {
    354         bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
    355     }
    356 
    357 }
    358 
    359 /*******************************************************************************
    360 **
    361 ** Function         bta_hl_dch_ci_put_rx_data
    362 **
    363 ** Description      Action routine for processing the call-in of the
    364 **                  put rx data event
    365 **
    366 ** Returns          void
    367 **
    368 *******************************************************************************/
    369 void bta_hl_dch_ci_put_rx_data(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
    370                                tBTA_HL_DATA *p_data)
    371 {
    372     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
    373     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
    374     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
    375     tBTA_HL             evt_data;
    376 
    377 #if (BTA_HL_DEBUG == TRUE)
    378     APPL_TRACE_DEBUG0("bta_hl_dch_ci_put_rx_data");
    379 #endif
    380 
    381     p_dcb->cout_oper &= ~BTA_HL_CO_PUT_RX_DATA_MASK;
    382     utl_freebuf((void **) &p_dcb->p_rx_pkt);
    383     bta_hl_build_rcv_data_ind(&evt_data,
    384                               p_acb->app_handle,
    385                               p_mcb->mcl_handle,
    386                               p_dcb->mdl_handle);
    387     p_acb->p_cback(BTA_HL_DCH_RCV_DATA_IND_EVT,(tBTA_HL *) &evt_data );
    388     if (p_dcb->close_pending)
    389     {
    390         if (!p_dcb->cout_oper)
    391         {
    392             bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_EVT, p_data);
    393         }
    394 
    395     }
    396 }
    397 
    398 
    399 
    400 /*******************************************************************************
    401 **
    402 ** Function         bta_hl_dch_ci_get_tx_data
    403 **
    404 ** Description      Action routine for processing the call-in of the
    405 **                  get tx data event
    406 **
    407 ** Returns          void
    408 **
    409 *******************************************************************************/
    410 void bta_hl_dch_ci_get_tx_data(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
    411                                tBTA_HL_DATA *p_data)
    412 {
    413     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
    414     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
    415     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
    416     tMCA_RESULT         result;
    417     tBTA_HL_STATUS      status = BTA_HL_STATUS_OK;
    418     BOOLEAN             free_buf = FALSE;
    419     BOOLEAN             close_dch = FALSE;
    420     tBTA_HL             evt_data;
    421 
    422 
    423 #if (BTA_HL_DEBUG == TRUE)
    424     APPL_TRACE_DEBUG0("bta_hl_dch_ci_get_tx_data");
    425 #endif
    426 
    427     p_dcb->cout_oper &= ~BTA_HL_CO_GET_TX_DATA_MASK;
    428 
    429     if (p_dcb->close_pending)
    430     {
    431         status = BTA_HL_STATUS_FAIL;
    432         free_buf = TRUE;
    433 
    434         if (!p_dcb->cout_oper)
    435         {
    436             close_dch = TRUE;
    437         }
    438     }
    439     else
    440     {
    441         if ((result = MCA_WriteReq((tMCA_DL) p_dcb->mdl_handle, p_dcb->p_tx_pkt)) != MCA_SUCCESS)
    442         {
    443             if (result == MCA_BUSY)
    444             {
    445                 status = BTA_HL_STATUS_DCH_BUSY;
    446             }
    447             else
    448             {
    449                 status = BTA_HL_STATUS_FAIL;
    450             }
    451             free_buf = TRUE;
    452         }
    453         else
    454         {
    455             p_dcb->p_tx_pkt = NULL;
    456         }
    457     }
    458 
    459     if (free_buf)
    460     {
    461         utl_freebuf((void **) &p_dcb->p_tx_pkt);
    462     }
    463 
    464     bta_hl_build_send_data_cfm(&evt_data,
    465                                p_acb->app_handle,
    466                                p_mcb->mcl_handle,
    467                                p_dcb->mdl_handle,
    468                                status);
    469     p_acb->p_cback(BTA_HL_DCH_SEND_DATA_CFM_EVT,(tBTA_HL *) &evt_data );
    470 
    471     if (close_dch)
    472     {
    473         bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_EVT, p_data);
    474     }
    475 }
    476 
    477 
    478 /*******************************************************************************
    479 **
    480 ** Function         bta_hl_dch_send_data
    481 **
    482 ** Description      Action routine for processing api send data request
    483 **
    484 ** Returns          void
    485 **
    486 *******************************************************************************/
    487 void bta_hl_dch_send_data(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
    488                           tBTA_HL_DATA *p_data)
    489 {
    490     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
    491     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
    492     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
    493     tBTA_HL             evt_data;
    494     BOOLEAN             success = TRUE;
    495 
    496 #if (BTA_HL_DEBUG == TRUE)
    497     APPL_TRACE_DEBUG0("bta_hl_dch_send_data");
    498 #endif
    499 
    500     if (!(p_dcb->cout_oper & BTA_HL_CO_GET_TX_DATA_MASK))
    501     {
    502         if ((p_dcb->p_tx_pkt = bta_hl_get_buf(p_data->api_send_data.pkt_size)) != NULL)
    503         {
    504             bta_hl_co_get_tx_data( p_acb->app_id,
    505                                    p_dcb->mdl_handle,
    506                                    p_data->api_send_data.pkt_size,
    507                                    BTA_HL_GET_BUF_PTR(p_dcb->p_tx_pkt),
    508                                    BTA_HL_CI_GET_TX_DATA_EVT);
    509             p_dcb->cout_oper |= BTA_HL_CO_GET_TX_DATA_MASK;
    510         }
    511         else
    512         {
    513             success = FALSE;
    514         }
    515     }
    516     else
    517     {
    518         success = FALSE;
    519     }
    520 
    521     if (!success)
    522     {
    523         bta_hl_build_send_data_cfm(&evt_data,
    524                                    p_acb->app_handle,
    525                                    p_mcb->mcl_handle,
    526                                    p_dcb->mdl_handle,
    527                                    BTA_HL_STATUS_FAIL);
    528         p_acb->p_cback(BTA_HL_DCH_SEND_DATA_CFM_EVT,(tBTA_HL *) &evt_data );
    529     }
    530 }
    531 
    532 /*******************************************************************************
    533 **
    534 ** Function         bta_hl_dch_close_cmpl
    535 **
    536 ** Description      Action routine for processing the close complete event
    537 **
    538 ** Returns          void
    539 **
    540 *******************************************************************************/
    541 void bta_hl_dch_close_cmpl(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
    542                            tBTA_HL_DATA *p_data)
    543 {
    544     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
    545     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
    546     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
    547     tBTA_HL             evt_data;
    548     tBTA_HL_EVT         event = 0;
    549     BOOLEAN             send_evt=TRUE;
    550     tBTA_HL_STATUS      status;
    551 
    552 #if (BTA_HL_DEBUG == TRUE)
    553 #if (BT_TRACE_VERBOSE == TRUE)
    554     APPL_TRACE_DEBUG1("bta_hl_dch_close_cmpl dch oper=%s", bta_hl_dch_oper_code(p_dcb->dch_oper));
    555 #else
    556     APPL_TRACE_DEBUG1("bta_hl_dch_close_cmpl dch oper=%d", p_dcb->dch_oper);
    557 #endif
    558 #endif
    559 
    560     switch (p_dcb->dch_oper)
    561     {
    562         case BTA_HL_DCH_OP_LOCAL_OPEN:
    563         case BTA_HL_DCH_OP_LOCAL_RECONNECT:
    564 
    565             if (p_dcb->abort_oper & BTA_HL_ABORT_LOCAL_MASK)
    566             {
    567                 bta_hl_build_abort_cfm(&evt_data,
    568                                        p_acb->app_handle,
    569                                        p_mcb->mcl_handle,
    570                                        BTA_HL_STATUS_OK);
    571                 event = BTA_HL_DCH_ABORT_CFM_EVT;
    572             }
    573             else if (p_dcb->abort_oper & BTA_HL_ABORT_REMOTE_MASK )
    574             {
    575                 bta_hl_build_abort_ind(&evt_data,
    576                                        p_acb->app_handle,
    577                                        p_mcb->mcl_handle);
    578                 event = BTA_HL_DCH_ABORT_IND_EVT;
    579             }
    580             else
    581             {
    582                 bta_hl_build_dch_open_cfm(&evt_data,
    583                                           p_acb->app_handle,
    584                                           p_mcb->mcl_handle,
    585                                           BTA_HL_INVALID_MDL_HANDLE,
    586                                           0,0,0,0,0, BTA_HL_STATUS_FAIL);
    587                 event = BTA_HL_DCH_OPEN_CFM_EVT;
    588                 if (p_dcb->dch_oper == BTA_HL_DCH_OP_LOCAL_RECONNECT)
    589                 {
    590                     event = BTA_HL_DCH_RECONNECT_CFM_EVT;
    591                 }
    592             }
    593             break;
    594 
    595         case BTA_HL_DCH_OP_LOCAL_CLOSE:
    596         case BTA_HL_DCH_OP_REMOTE_DELETE:
    597         case BTA_HL_DCH_OP_LOCAL_CLOSE_RECONNECT:
    598         case BTA_HL_DCH_OP_NONE:
    599 
    600             bta_hl_build_dch_close_cfm(&evt_data,
    601                                        p_acb->app_handle,
    602                                        p_mcb->mcl_handle,
    603                                        p_dcb->mdl_handle,
    604                                        BTA_HL_STATUS_OK);
    605             event = BTA_HL_DCH_CLOSE_CFM_EVT;
    606             break;
    607 
    608         case BTA_HL_DCH_OP_REMOTE_CLOSE:
    609             bta_hl_build_dch_close_ind(&evt_data,
    610                                        p_acb->app_handle,
    611                                        p_mcb->mcl_handle,
    612                                        p_dcb->mdl_handle,
    613                                        p_dcb->intentional_close);
    614             event = BTA_HL_DCH_CLOSE_IND_EVT;
    615             break;
    616 
    617         case BTA_HL_DCH_OP_REMOTE_OPEN:
    618 
    619             if (p_dcb->abort_oper & BTA_HL_ABORT_LOCAL_MASK)
    620             {
    621                 bta_hl_build_abort_cfm(&evt_data,
    622                                        p_acb->app_handle,
    623                                        p_mcb->mcl_handle,
    624                                        BTA_HL_STATUS_OK);
    625                 event = BTA_HL_DCH_ABORT_CFM_EVT;
    626             }
    627             else if (p_dcb->abort_oper & BTA_HL_ABORT_REMOTE_MASK )
    628             {
    629                 bta_hl_build_abort_ind(&evt_data,
    630                                        p_acb->app_handle,
    631                                        p_mcb->mcl_handle);
    632                 event = BTA_HL_DCH_ABORT_IND_EVT;
    633             }
    634             else
    635             {
    636                 bta_hl_build_dch_close_ind(&evt_data,
    637                                            p_acb->app_handle,
    638                                            p_mcb->mcl_handle,
    639                                            p_dcb->mdl_handle,
    640                                            p_dcb->intentional_close);
    641                 event = BTA_HL_DCH_CLOSE_IND_EVT;
    642             }
    643             break;
    644 
    645         case BTA_HL_DCH_OP_LOCAL_CLOSE_ECHO_TEST:
    646             /* this is normal echo test close */
    647         case BTA_HL_DCH_OP_REMOTE_CREATE:
    648         case BTA_HL_DCH_OP_REMOTE_RECONNECT:
    649             send_evt=FALSE;
    650             break;
    651 
    652         default:
    653 #if (BTA_HL_DEBUG == TRUE)
    654 #if (BT_TRACE_VERBOSE == TRUE)
    655             APPL_TRACE_ERROR1("DCH operation not found oper=%s", bta_hl_dch_oper_code(p_dcb->dch_oper));
    656 #else
    657             APPL_TRACE_ERROR1("DCH operation not found oper=%d", p_dcb->dch_oper);
    658 #endif
    659 #endif
    660             send_evt=FALSE;
    661             break;
    662     }
    663 
    664     if ( p_dcb->local_mdep_id == BTA_HL_ECHO_TEST_MDEP_ID )
    665     {
    666         p_mcb->echo_test = FALSE;
    667         send_evt=FALSE;
    668 
    669         if ( p_dcb->dch_oper != BTA_HL_DCH_OP_LOCAL_CLOSE_ECHO_TEST)
    670         {
    671             switch (p_dcb->echo_oper)
    672             {
    673                 case BTA_HL_ECHO_OP_CI_GET_ECHO_DATA:
    674                 case BTA_HL_ECHO_OP_SDP_INIT:
    675                 case BTA_HL_ECHO_OP_MDL_CREATE_CFM:
    676                 case BTA_HL_ECHO_OP_DCH_OPEN_CFM:
    677                 case BTA_HL_ECHO_OP_LOOP_BACK:
    678 
    679                     status = BTA_HL_STATUS_FAIL;
    680                     send_evt = TRUE;
    681                     break;
    682                 case BTA_HL_ECHO_OP_OPEN_IND:
    683                 case BTA_HL_ECHO_OP_ECHO_PKT:
    684                     break;
    685                 default:
    686                     APPL_TRACE_ERROR1("Invalid echo_oper=%d", p_dcb->echo_oper);
    687                     break;
    688             }
    689         }
    690         else
    691         {
    692             status = p_dcb->ci_put_echo_data_status;
    693             send_evt = TRUE;
    694         }
    695 
    696         if (send_evt)
    697         {
    698             bta_hl_build_echo_test_cfm(&evt_data,
    699                                        p_acb->app_handle,
    700                                        p_mcb->mcl_handle,
    701                                        status);
    702             event = BTA_HL_DCH_ECHO_TEST_CFM_EVT;
    703         }
    704     }
    705 
    706     bta_hl_clean_mdl_cb(app_idx, mcl_idx, mdl_idx);
    707 
    708     if (send_evt)
    709     {
    710         if (p_acb->p_cback)
    711         {
    712 #if (BTA_HL_DEBUG == TRUE)
    713 #if (BT_TRACE_VERBOSE == TRUE)
    714             APPL_TRACE_DEBUG1("Send Event: %s",  bta_hl_cback_evt_code(event));
    715 #else
    716             APPL_TRACE_DEBUG1("Send Event: 0x%02x", event);
    717 #endif
    718 #endif
    719             p_acb->p_cback(event,(tBTA_HL *) &evt_data );
    720         }
    721     }
    722     /* check cch close is in progress or not */
    723     bta_hl_check_cch_close(app_idx, mcl_idx, p_data, FALSE);
    724 }
    725 /*******************************************************************************
    726 **
    727 ** Function         bta_hl_dch_mca_close_ind
    728 **
    729 ** Description      Action routine for processing the close indication
    730 **
    731 ** Returns          void
    732 **
    733 *******************************************************************************/
    734 void bta_hl_dch_mca_close_ind(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
    735                               tBTA_HL_DATA *p_data)
    736 {
    737     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
    738 
    739 #if (BTA_HL_DEBUG == TRUE)
    740 #if (BT_TRACE_VERBOSE == TRUE)
    741     APPL_TRACE_DEBUG1("bta_hl_dch_mca_close_ind dch oper=%s", bta_hl_dch_oper_code(p_dcb->dch_oper));
    742 #else
    743     APPL_TRACE_DEBUG1("bta_hl_dch_mca_close_ind dch oper=%d", p_dcb->dch_oper);
    744 #endif
    745 #endif
    746 
    747     p_dcb->intentional_close = FALSE;
    748     if (p_data->mca_evt.mca_data.close_ind.reason == L2CAP_DISC_OK)
    749     {
    750         p_dcb->intentional_close = TRUE;
    751     }
    752 
    753     if (!p_dcb->cout_oper)
    754     {
    755         if ((p_dcb->dch_oper != BTA_HL_DCH_OP_REMOTE_OPEN) &&
    756             (p_dcb->dch_oper != BTA_HL_DCH_OP_REMOTE_RECONNECT))
    757         {
    758             p_dcb->dch_oper = BTA_HL_DCH_OP_REMOTE_CLOSE;
    759         }
    760         bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
    761     }
    762     else
    763     {
    764         p_dcb->close_pending = TRUE;
    765     }
    766 }
    767 
    768 /*******************************************************************************
    769 **
    770 ** Function         bta_hl_dch_mca_close_cfm
    771 **
    772 ** Description      Action routine for processing the close confirmation
    773 **
    774 ** Returns          void
    775 **
    776 *******************************************************************************/
    777 void bta_hl_dch_mca_close_cfm(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
    778                               tBTA_HL_DATA *p_data)
    779 {
    780     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
    781 
    782 
    783 #if (BTA_HL_DEBUG == TRUE)
    784 #if (BT_TRACE_VERBOSE == TRUE)
    785     APPL_TRACE_DEBUG1("bta_hl_dch_mca_close_cfm dch_oper=%s", bta_hl_dch_oper_code(p_dcb->dch_oper) );
    786 #else
    787     APPL_TRACE_DEBUG1("bta_hl_dch_mca_close_cfm dch_oper=%d", p_dcb->dch_oper);
    788 #endif
    789 #endif
    790 
    791     switch (p_dcb->dch_oper)
    792     {
    793         case BTA_HL_DCH_OP_LOCAL_CLOSE:
    794         case BTA_HL_DCH_OP_LOCAL_OPEN:
    795         case BTA_HL_DCH_OP_LOCAL_RECONNECT:
    796         case BTA_HL_DCH_OP_LOCAL_CLOSE_ECHO_TEST:
    797         case BTA_HL_DCH_OP_REMOTE_DELETE:
    798         case BTA_HL_DCH_OP_LOCAL_CLOSE_RECONNECT:
    799         case BTA_HL_DCH_OP_NONE:
    800             bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
    801             break;
    802         default:
    803 #if (BTA_HL_DEBUG == TRUE)
    804 #if (BT_TRACE_VERBOSE == TRUE)
    805             APPL_TRACE_ERROR1("Invalid dch_oper=%s for close cfm", bta_hl_dch_oper_code(p_dcb->dch_oper) );
    806 #else
    807             APPL_TRACE_ERROR1("Invalid dch_oper=%d for close cfm", p_dcb->dch_oper);
    808 #endif
    809 #endif
    810             break;
    811     }
    812 
    813 }
    814 
    815 /*******************************************************************************
    816 **
    817 ** Function         bta_hl_dch_mca_close
    818 **
    819 ** Description      Action routine for processing the DCH close request
    820 **
    821 ** Returns          void
    822 **
    823 *******************************************************************************/
    824 void bta_hl_dch_mca_close(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
    825                           tBTA_HL_DATA *p_data)
    826 {
    827     tBTA_HL_APP_CB          *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
    828     tBTA_HL_MCL_CB          *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
    829     tBTA_HL_MDL_CB          *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
    830     tBTA_HL_STATUS          status = BTA_HL_STATUS_OK;
    831     tBTA_HL                 evt_data;
    832 
    833 #if (BTA_HL_DEBUG == TRUE)
    834     APPL_TRACE_DEBUG0("bta_hl_dch_mca_close");
    835 #endif
    836     if (!p_dcb->cout_oper)
    837     {
    838         p_dcb->close_pending = FALSE;
    839         if (MCA_CloseReq((tMCA_DL)p_dcb->mdl_handle)== MCA_SUCCESS)
    840         {
    841             p_dcb->dch_oper = BTA_HL_DCH_OP_LOCAL_CLOSE;
    842         }
    843         else
    844         {
    845             status = BTA_HL_STATUS_FAIL;
    846         }
    847 
    848         if ((status != BTA_HL_STATUS_OK) &&
    849             (p_mcb->cch_close_dch_oper != BTA_HL_CCH_CLOSE_OP_DCH_CLOSE))
    850         {
    851             bta_hl_build_dch_close_cfm(&evt_data,
    852                                        p_acb->app_handle,
    853                                        p_mcb->mcl_handle,
    854                                        p_data->api_dch_close.mdl_handle,
    855                                        status);
    856             p_acb->p_cback(BTA_HL_DCH_CLOSE_CFM_EVT,(tBTA_HL *) &evt_data );
    857         }
    858     }
    859     else
    860     {
    861         p_dcb->close_pending = TRUE;
    862     }
    863 }
    864 
    865 
    866 /*******************************************************************************
    867 **
    868 ** Function         bta_hl_dch_mca_open_ind
    869 **
    870 ** Description      Action routine for processing the open indication
    871 **
    872 ** Returns          void
    873 **
    874 *******************************************************************************/
    875 void bta_hl_dch_mca_open_ind(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
    876                              tBTA_HL_DATA *p_data)
    877 {
    878     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
    879     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
    880     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
    881     tMCA_DL_OPEN        *p_open_ind = &p_data->mca_evt.mca_data.open_ind;
    882     tBTA_HL             evt_data;
    883     tBTA_HL_EVT         event;
    884     UINT8               old_dch_oper = BTA_HL_DCH_OP_NONE;
    885     BOOLEAN             send_event = FALSE;
    886 
    887 
    888 #if (BTA_HL_DEBUG == TRUE)
    889     APPL_TRACE_DEBUG0("bta_hl_dch_mca_open_ind");
    890 #endif
    891     if ((p_dcb->dch_oper == BTA_HL_DCH_OP_REMOTE_OPEN) ||
    892         (p_dcb->dch_oper == BTA_HL_DCH_OP_REMOTE_RECONNECT)    )
    893     {
    894         p_dcb->mdl_handle = (tBTA_HL_MDL_HANDLE) p_open_ind->mdl;
    895         p_dcb->mtu        = p_open_ind->mtu;
    896 
    897         evt_data.dch_open_ind.mdl_handle = p_dcb->mdl_handle;
    898         evt_data.dch_open_ind.mcl_handle = p_mcb->mcl_handle;
    899         evt_data.dch_open_ind.app_handle = p_acb->app_handle;
    900 
    901         evt_data.dch_open_ind.local_mdep_id = p_dcb->local_mdep_id;
    902         evt_data.dch_open_ind.mdl_id = p_dcb->mdl_id;
    903         evt_data.dch_open_ind.mtu = p_dcb->mtu;
    904 
    905         if ( p_dcb->chnl_cfg.fcr_opt.mode == L2CAP_FCR_ERTM_MODE )
    906         {
    907             evt_data.dch_open_ind.dch_mode = BTA_HL_DCH_MODE_RELIABLE;
    908             if (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx))
    909             {
    910                 p_dcb->is_the_first_reliable = TRUE;
    911             }
    912         }
    913         else
    914         {
    915             evt_data.dch_open_ind.dch_mode = BTA_HL_DCH_MODE_STREAMING;
    916         }
    917         evt_data.dch_open_ind.first_reliable = p_dcb->is_the_first_reliable ;
    918 
    919         old_dch_oper = p_dcb->dch_oper;
    920         p_dcb->dch_oper = BTA_HL_DCH_OP_NONE;
    921 
    922 
    923     }
    924 
    925     switch (old_dch_oper)
    926     {
    927         case BTA_HL_DCH_OP_REMOTE_OPEN:
    928 
    929             p_dcb->dch_mode = evt_data.dch_open_ind.dch_mode;
    930             if (p_dcb->local_mdep_id != BTA_HL_ECHO_TEST_MDEP_ID)
    931             {
    932                 bta_hl_save_mdl_cfg(app_idx, mcl_idx,mdl_idx);
    933                 event= BTA_HL_DCH_OPEN_IND_EVT;
    934                 send_event= TRUE;
    935             }
    936             else
    937             {
    938                 p_dcb->echo_oper = BTA_HL_ECHO_OP_ECHO_PKT;
    939             }
    940 
    941             break;
    942 
    943         case BTA_HL_DCH_OP_REMOTE_RECONNECT:
    944 
    945             if (bta_hl_validate_chan_cfg(app_idx, mcl_idx, mdl_idx))
    946             {
    947                 bta_hl_save_mdl_cfg(app_idx, mcl_idx,mdl_idx);
    948                 event= BTA_HL_DCH_RECONNECT_IND_EVT;
    949                 send_event= TRUE;
    950             }
    951             else
    952             {
    953                 if (MCA_CloseReq((tMCA_DL) p_dcb->mdl_handle) == MCA_SUCCESS)
    954                 {
    955                     p_dcb->dch_oper = BTA_HL_DCH_OP_LOCAL_CLOSE_RECONNECT;
    956                 }
    957                 else
    958                 {
    959                     APPL_TRACE_ERROR0("Unabel to close DCH for reconnect cfg mismatch");
    960                 }
    961             }
    962             break;
    963         default:
    964             break;
    965     }
    966 
    967     if (send_event)
    968     {
    969         p_acb->p_cback(event ,(tBTA_HL *) &evt_data );
    970     }
    971 }
    972 
    973 /*******************************************************************************
    974 **
    975 ** Function         bta_hl_dch_mca_open_cfm
    976 **
    977 ** Description      Action routine for processing the open confirmation
    978 **
    979 ** Returns          void
    980 **
    981 *******************************************************************************/
    982 void bta_hl_dch_mca_open_cfm(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
    983                              tBTA_HL_DATA *p_data)
    984 {
    985     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
    986     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
    987     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
    988     tMCA_DL_OPEN        *p_open_cfm = &p_data->mca_evt.mca_data.open_cfm;
    989     tBTA_HL             evt_data;
    990     tBTA_HL_EVT         event;
    991     UINT8               old_dch_oper = BTA_HL_DCH_OP_NONE;
    992     tBTA_HL_DCH_MODE    dch_mode = BTA_HL_DCH_MODE_STREAMING;
    993     BOOLEAN             send_event = FALSE;
    994 
    995 
    996 #if (BTA_HL_DEBUG == TRUE)
    997     APPL_TRACE_DEBUG0("bta_hl_dch_mca_open_cfm");
    998 #endif
    999     if ((p_dcb->dch_oper == BTA_HL_DCH_OP_LOCAL_OPEN) ||
   1000         (p_dcb->dch_oper == BTA_HL_DCH_OP_LOCAL_RECONNECT))
   1001     {
   1002         p_dcb->mdl_handle = (tBTA_HL_MDL_HANDLE) p_open_cfm->mdl;
   1003         p_dcb->mtu        = p_open_cfm->mtu;
   1004 
   1005         /*todo verify dch_mode, mtu and fcs for reconnect */
   1006         if ( p_dcb->chnl_cfg.fcr_opt.mode == L2CAP_FCR_ERTM_MODE )
   1007         {
   1008             dch_mode = BTA_HL_DCH_MODE_RELIABLE;
   1009         }
   1010 
   1011         if (p_dcb->local_mdep_id != BTA_HL_ECHO_TEST_MDEP_ID)
   1012         {
   1013             if (dch_mode == BTA_HL_DCH_MODE_RELIABLE )
   1014             {
   1015                 if (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx))
   1016                 {
   1017                     p_dcb->is_the_first_reliable = TRUE;
   1018                 }
   1019             }
   1020         }
   1021 
   1022         bta_hl_build_dch_open_cfm(&evt_data, p_acb->app_handle,
   1023                                   p_mcb->mcl_handle,
   1024                                   p_dcb->mdl_handle,
   1025                                   p_dcb->local_mdep_id,
   1026                                   p_dcb->mdl_id, dch_mode,
   1027                                   p_dcb->is_the_first_reliable,
   1028                                   p_dcb->mtu,
   1029                                   BTA_HL_STATUS_OK);
   1030 
   1031         old_dch_oper = p_dcb->dch_oper;
   1032         p_dcb->dch_oper = BTA_HL_DCH_OP_NONE;
   1033     }
   1034     else
   1035     {
   1036         APPL_TRACE_ERROR1("Error dch oper =%d",  p_dcb->dch_oper);
   1037         return;
   1038     }
   1039 
   1040     switch (old_dch_oper)
   1041     {
   1042         case BTA_HL_DCH_OP_LOCAL_OPEN:
   1043 
   1044             p_dcb->dch_mode = dch_mode;
   1045             if (p_dcb->local_mdep_id != BTA_HL_ECHO_TEST_MDEP_ID)
   1046             {
   1047                 bta_hl_save_mdl_cfg(app_idx, mcl_idx, mdl_idx);
   1048                 event= BTA_HL_DCH_OPEN_CFM_EVT;
   1049                 send_event= TRUE;
   1050             }
   1051             else
   1052             {
   1053                 p_dcb->echo_oper = BTA_HL_ECHO_OP_LOOP_BACK;
   1054                 if (MCA_WriteReq((tMCA_DL) p_dcb->mdl_handle, p_dcb->p_echo_tx_pkt)!= MCA_SUCCESS)
   1055                 {
   1056                     bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_ECHO_TEST_EVT, p_data);
   1057                 }
   1058                 else
   1059                 {
   1060                     p_dcb->p_echo_tx_pkt = NULL;
   1061                 }
   1062             }
   1063             break;
   1064 
   1065         case BTA_HL_DCH_OP_LOCAL_RECONNECT:
   1066 
   1067             if (bta_hl_validate_chan_cfg(app_idx, mcl_idx, mdl_idx))
   1068             {
   1069                 bta_hl_save_mdl_cfg(app_idx, mcl_idx,mdl_idx);
   1070                 event= BTA_HL_DCH_RECONNECT_CFM_EVT;
   1071                 send_event= TRUE;
   1072             }
   1073             else
   1074             {
   1075                 if (MCA_CloseReq((tMCA_DL) p_dcb->mdl_handle) == MCA_SUCCESS)
   1076                 {
   1077                     p_dcb->dch_oper = BTA_HL_DCH_OP_LOCAL_CLOSE_RECONNECT;
   1078                 }
   1079                 else
   1080                 {
   1081                     APPL_TRACE_ERROR0("Unabel to close DCH for reconnect cfg mismatch");
   1082                 }
   1083             }
   1084             break;
   1085         default:
   1086             break;
   1087     }
   1088 
   1089     if (send_event)
   1090         p_acb->p_cback(event ,(tBTA_HL *) &evt_data );
   1091 }
   1092 
   1093 
   1094 /*******************************************************************************
   1095 **
   1096 ** Function         bta_hl_dch_mca_abort_ind
   1097 **
   1098 ** Description      Action routine for processing the abort indication
   1099 **
   1100 ** Returns          void
   1101 **
   1102 *******************************************************************************/
   1103 void bta_hl_dch_mca_abort_ind(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
   1104                               tBTA_HL_DATA *p_data)
   1105 {
   1106     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
   1107 
   1108 
   1109 #if (BTA_HL_DEBUG == TRUE)
   1110     APPL_TRACE_DEBUG0("bta_hl_dch_mca_abort_ind");
   1111 #endif
   1112 
   1113     p_dcb->abort_oper |= BTA_HL_ABORT_REMOTE_MASK;
   1114     bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
   1115 }
   1116 
   1117 /*******************************************************************************
   1118 **
   1119 ** Function         bta_hl_dch_mca_abort_cfm
   1120 **
   1121 ** Description      Action routine for processing the abort confirmation
   1122 **
   1123 ** Returns          void
   1124 **
   1125 *******************************************************************************/
   1126 void bta_hl_dch_mca_abort_cfm(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
   1127                               tBTA_HL_DATA *p_data)
   1128 {
   1129     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
   1130     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   1131     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
   1132     tBTA_HL             evt_data;
   1133 
   1134 #if (BTA_HL_DEBUG == TRUE)
   1135     APPL_TRACE_DEBUG0("bta_hl_dch_mca_abort_cfm");
   1136 #endif
   1137 
   1138     if (p_dcb->abort_oper)
   1139     {
   1140         if (p_data->mca_evt.mca_data.abort_cfm.rsp_code != MCA_RSP_SUCCESS )
   1141         {
   1142             if (p_dcb->abort_oper & BTA_HL_ABORT_LOCAL_MASK)
   1143             {
   1144                 bta_hl_build_abort_cfm(&evt_data,
   1145                                        p_acb->app_handle,
   1146                                        p_mcb->mcl_handle,
   1147                                        BTA_HL_STATUS_FAIL);
   1148                 p_acb->p_cback(BTA_HL_DCH_ABORT_CFM_EVT ,(tBTA_HL *) &evt_data );
   1149             }
   1150         }
   1151         else
   1152         {
   1153             bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
   1154         }
   1155     }
   1156     else
   1157     {
   1158         APPL_TRACE_ERROR0("Not expecting Abort CFM ");
   1159     }
   1160 }
   1161 
   1162 /*******************************************************************************
   1163 **
   1164 ** Function         bta_hl_dch_mca_abort
   1165 **
   1166 ** Description      Action routine for processing the abort request
   1167 **
   1168 ** Returns          void
   1169 **
   1170 *******************************************************************************/
   1171 void bta_hl_dch_mca_abort(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
   1172                           tBTA_HL_DATA *p_data)
   1173 {
   1174     tBTA_HL_APP_CB          *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
   1175     tBTA_HL_MCL_CB          *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   1176     tBTA_HL_MDL_CB          *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
   1177     tMCA_RESULT             mca_result;
   1178     tBTA_HL                 evt_data;
   1179 
   1180     if (((p_mcb->sdp_oper == BTA_HL_SDP_OP_DCH_OPEN_INIT) ||
   1181          (p_mcb->sdp_oper == BTA_HL_SDP_OP_DCH_RECONNECT_INIT)) &&
   1182         (p_mcb->sdp_mdl_idx == mdl_idx) )
   1183     {
   1184         p_dcb->abort_oper |= BTA_HL_ABORT_PENDING_MASK;
   1185         return;
   1186     }
   1187     else if (p_dcb->echo_oper == BTA_HL_ECHO_OP_CI_GET_ECHO_DATA)
   1188     {
   1189         p_dcb->abort_oper |= BTA_HL_ABORT_PENDING_MASK;
   1190         return;
   1191     }
   1192 
   1193     p_dcb->abort_oper &= ~BTA_HL_ABORT_PENDING_MASK;
   1194 
   1195     if ((mca_result = MCA_Abort((tMCA_CL) p_mcb->mcl_handle))!= MCA_SUCCESS)
   1196     {
   1197         if (mca_result == MCA_NO_RESOURCES)
   1198         {
   1199             p_dcb->abort_oper |= BTA_HL_ABORT_PENDING_MASK;
   1200         }
   1201         else
   1202         {
   1203             if (p_dcb->abort_oper & BTA_HL_ABORT_LOCAL_MASK)
   1204             {
   1205                 bta_hl_build_abort_cfm(&evt_data,
   1206                                        p_acb->app_handle,
   1207                                        p_mcb->mcl_handle,
   1208                                        BTA_HL_STATUS_FAIL);
   1209                 p_acb->p_cback(BTA_HL_DCH_ABORT_CFM_EVT ,(tBTA_HL *) &evt_data );
   1210             }
   1211             bta_hl_check_cch_close(app_idx, mcl_idx, p_data, FALSE);
   1212         }
   1213 
   1214 
   1215     }
   1216 
   1217 #if (BTA_HL_DEBUG == TRUE)
   1218     APPL_TRACE_DEBUG1("bta_hl_dch_mca_abort abort_oper=0x%x", p_dcb->abort_oper);
   1219 #endif
   1220 
   1221 }
   1222 
   1223 /*******************************************************************************
   1224 **
   1225 ** Function         bta_hl_dch_mca_reconnect_ind
   1226 **
   1227 ** Description      Action routine for processing the reconnect indication
   1228 **
   1229 ** Returns          void
   1230 **
   1231 *******************************************************************************/
   1232 void bta_hl_dch_mca_reconnect_ind(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
   1233                                   tBTA_HL_DATA *p_data)
   1234 {
   1235     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   1236     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
   1237     tBTA_HL_MDL_CFG     *p_mdl_cfg;
   1238     tMCA_EVT_HDR        *p_reconnect_ind = &p_data->mca_evt.mca_data.reconnect_ind;
   1239     UINT8               mdl_cfg_idx, in_use_mdl_idx, mdep_cfg_idx;
   1240     UINT8               rsp_code = MCA_RSP_SUCCESS;
   1241 
   1242 
   1243 #if (BTA_HL_DEBUG == TRUE)
   1244     APPL_TRACE_DEBUG1("bta_hl_dch_mca_reconnect_ind mdl_id=%d", p_reconnect_ind->mdl_id);
   1245 #endif
   1246 
   1247     if (bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, p_reconnect_ind->mdl_id, &mdl_cfg_idx))
   1248     {
   1249         if (!bta_hl_find_mdl_idx(app_idx,mcl_idx,p_reconnect_ind->mdl_id, &in_use_mdl_idx) )
   1250         {
   1251             p_mdl_cfg =  BTA_HL_GET_MDL_CFG_PTR(app_idx, mdl_cfg_idx);
   1252 
   1253             if (bta_hl_find_mdep_cfg_idx(app_idx, p_mdl_cfg->local_mdep_id, &mdep_cfg_idx))
   1254             {
   1255                 p_dcb->in_use               = TRUE;
   1256                 p_dcb->dch_oper             = BTA_HL_DCH_OP_REMOTE_RECONNECT;
   1257                 p_dcb->sec_mask             = (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT);
   1258                 p_dcb->peer_mdep_id             = 0xFF;
   1259                 p_dcb->local_mdep_id        = p_mdl_cfg->local_mdep_id  ;
   1260                 p_dcb->local_mdep_cfg_idx   = mdep_cfg_idx;
   1261                 p_dcb->local_cfg            = BTA_HL_DCH_CFG_UNKNOWN;
   1262                 p_dcb->mdl_id               = p_reconnect_ind->mdl_id;
   1263                 p_dcb->mdl_cfg_idx_included = TRUE;
   1264                 p_dcb->mdl_cfg_idx          = mdl_cfg_idx;
   1265                 p_dcb->dch_mode             = p_mdl_cfg->dch_mode;
   1266                 bta_hl_find_rxtx_apdu_size(app_idx, mdep_cfg_idx,
   1267                                            &p_dcb->max_rx_apdu_size,
   1268                                            &p_dcb->max_tx_apdu_size);
   1269                 bta_hl_set_dch_chan_cfg(app_idx, mcl_idx, mdl_idx, p_data);
   1270             }
   1271             else
   1272             {
   1273                 rsp_code = MCA_RSP_BAD_MDL;
   1274             }
   1275         }
   1276         else
   1277         {
   1278             rsp_code = MCA_RSP_BAD_MDL;
   1279         }
   1280     }
   1281     else
   1282     {
   1283         rsp_code = MCA_RSP_BAD_MDL;
   1284     }
   1285 
   1286     if (MCA_ReconnectMdlRsp((tMCA_CL) p_mcb->mcl_handle,
   1287                             p_dcb->local_mdep_id,
   1288                             p_dcb->mdl_id,
   1289                             rsp_code,
   1290                             &p_dcb->chnl_cfg)!= MCA_SUCCESS)
   1291     {
   1292         MCA_Abort((tMCA_CL) p_mcb->mcl_handle);
   1293         bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
   1294     }
   1295 }
   1296 
   1297 /*******************************************************************************
   1298 **
   1299 ** Function         bta_hl_dch_mca_reconnect_cfm
   1300 **
   1301 ** Description      Action routine for processing the reconenct confirmation
   1302 **
   1303 ** Returns          void
   1304 **
   1305 *******************************************************************************/
   1306 void bta_hl_dch_mca_reconnect_cfm(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
   1307                                   tBTA_HL_DATA *p_data)
   1308 {
   1309     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   1310     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
   1311     tMCA_RSP_EVT        *p_reconnect_cfm = &p_data->mca_evt.mca_data.reconnect_cfm;
   1312 
   1313 
   1314 #if (BTA_HL_DEBUG == TRUE)
   1315     APPL_TRACE_DEBUG0("bta_hl_dch_mca_reconnect_cfm");
   1316 #endif
   1317     if (p_dcb->abort_oper & BTA_HL_ABORT_PENDING_MASK)
   1318     {
   1319         p_dcb->abort_oper &= ~BTA_HL_ABORT_PENDING_MASK;
   1320         bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_ABORT_EVT, p_data);
   1321         return;
   1322     }
   1323 
   1324 
   1325     if (p_dcb->dch_oper == BTA_HL_DCH_OP_LOCAL_RECONNECT)
   1326     {
   1327         if (p_reconnect_cfm->rsp_code == MCA_RSP_SUCCESS)
   1328         {
   1329 
   1330             bta_hl_set_dch_chan_cfg(app_idx, mcl_idx, mdl_idx, p_data);
   1331 
   1332             if (MCA_DataChnlCfg((tMCA_CL) p_mcb->mcl_handle, &p_dcb->chnl_cfg)!= MCA_SUCCESS)
   1333             {
   1334                 /* should be able to abort so no checking of the return code */
   1335                 MCA_Abort((tMCA_CL) p_mcb->mcl_handle);
   1336                 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
   1337             }
   1338         }
   1339         else
   1340         {
   1341             bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
   1342         }
   1343     }
   1344 }
   1345 
   1346 /*******************************************************************************
   1347 **
   1348 ** Function         bta_hl_dch_mca_reconnect
   1349 **
   1350 ** Description      Action routine for processing the reconnect request
   1351 **
   1352 ** Returns          void
   1353 **
   1354 *******************************************************************************/
   1355 void bta_hl_dch_mca_reconnect(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
   1356                               tBTA_HL_DATA *p_data)
   1357 {
   1358     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   1359     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
   1360     tMCA_CHNL_CFG       *p_chnl_cfg=NULL;
   1361     UINT8               sdp_idx;
   1362 
   1363 #if (BTA_HL_DEBUG == TRUE)
   1364     APPL_TRACE_DEBUG0("bta_hl_dch_mca_reconnect");
   1365 #endif
   1366     if (bta_hl_find_sdp_idx_using_ctrl_psm(&p_mcb->sdp, p_mcb->ctrl_psm, &sdp_idx))
   1367     {
   1368         p_mcb->data_psm = p_mcb->sdp.sdp_rec[sdp_idx].data_psm;
   1369         if ( MCA_ReconnectMdl((tMCA_CL) p_mcb->mcl_handle,
   1370                               p_dcb->local_mdep_id,
   1371                               p_mcb->data_psm,
   1372                               p_dcb->mdl_id,
   1373                               p_chnl_cfg ) != MCA_SUCCESS)
   1374         {
   1375             bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
   1376         }
   1377     }
   1378     else
   1379     {
   1380         bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
   1381     }
   1382 }
   1383 
   1384 
   1385 /*******************************************************************************
   1386 **
   1387 ** Function         bta_hl_dch_create_rsp
   1388 **
   1389 ** Description      Action routine for processing BTA_HL_API_DCH_CREATE_RSP_EVT
   1390 **
   1391 ** Returns          void
   1392 **
   1393 *******************************************************************************/
   1394 void bta_hl_dch_create_rsp(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
   1395                            tBTA_HL_DATA *p_data)
   1396 {
   1397     tBTA_HL_MCL_CB              *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   1398     tBTA_HL_MDL_CB              *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
   1399     tBTA_HL_API_DCH_CREATE_RSP  *p_create_rsp = &p_data->api_dch_create_rsp;
   1400     UINT8                       mca_rsp_code = MCA_RSP_SUCCESS;
   1401 
   1402 #if (BTA_HL_DEBUG == TRUE)
   1403     APPL_TRACE_DEBUG0("bta_hl_dch_create_rsp");
   1404 #endif
   1405     if (p_create_rsp->rsp_code == BTA_HL_DCH_CREATE_RSP_SUCCESS)
   1406     {
   1407         p_dcb->dch_oper             = BTA_HL_DCH_OP_REMOTE_OPEN;
   1408         p_dcb->local_cfg            = p_create_rsp->cfg_rsp;
   1409 
   1410 
   1411 
   1412         bta_hl_set_dch_chan_cfg(app_idx, mcl_idx, mdl_idx, p_data);
   1413     }
   1414     else
   1415     {
   1416         mca_rsp_code = MCA_RSP_CFG_REJ;
   1417     }
   1418 
   1419     if (MCA_CreateMdlRsp((tMCA_CL) p_mcb->mcl_handle,
   1420                          p_dcb->local_mdep_id,
   1421                          p_dcb->mdl_id,
   1422                          p_dcb->local_cfg,
   1423                          mca_rsp_code,
   1424                          &p_dcb->chnl_cfg)!= MCA_SUCCESS)
   1425     {
   1426         bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
   1427     }
   1428 }
   1429 
   1430 /*******************************************************************************
   1431 **
   1432 ** Function         bta_hl_dch_mca_create_ind
   1433 **
   1434 ** Description      Action routine for processing
   1435 **
   1436 ** Returns          void
   1437 **
   1438 *******************************************************************************/
   1439 void bta_hl_dch_mca_create_ind(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
   1440                                tBTA_HL_DATA *p_data)
   1441 {
   1442     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
   1443     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   1444     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
   1445     tMCA_CREATE_IND     *p_create_ind = &p_data->mca_evt.mca_data.create_ind;
   1446     UINT8               mdep_cfg_idx;
   1447     UINT8               cfg_rsp;
   1448     UINT8               rsp_code = MCA_RSP_SUCCESS;
   1449     BOOLEAN             send_create_ind_evt = FALSE;
   1450     tBTA_HL             evt_data;
   1451     tBTA_HL_ECHO_CFG    *p_echo_cfg;
   1452 
   1453 #if (BTA_HL_DEBUG == TRUE)
   1454     APPL_TRACE_DEBUG0("bta_hl_dch_mca_create_ind");
   1455 #endif
   1456 
   1457     if (bta_hl_find_mdep_cfg_idx(app_idx, p_create_ind->dep_id, &mdep_cfg_idx))
   1458     {
   1459         if (p_create_ind->dep_id == BTA_HL_ECHO_TEST_MDEP_ID )
   1460         {
   1461             if (bta_hl_find_echo_cfg_rsp(app_idx, mcl_idx, mdep_cfg_idx,p_create_ind->cfg, &cfg_rsp ))
   1462             {
   1463                 p_dcb->in_use               = TRUE;
   1464                 p_dcb->dch_oper             = BTA_HL_DCH_OP_REMOTE_OPEN;
   1465                 p_dcb->local_mdep_id        = p_create_ind->dep_id  ;
   1466                 p_dcb->local_mdep_cfg_idx   = mdep_cfg_idx;
   1467                 p_dcb->local_cfg            = cfg_rsp;
   1468                 p_dcb->remote_cfg           = p_create_ind->cfg ;
   1469                 p_dcb->mdl_id               = p_create_ind->mdl_id;
   1470                 p_dcb->mdl_cfg_idx_included = FALSE;
   1471                 p_echo_cfg                      = BTA_HL_GET_ECHO_CFG_PTR(app_idx);
   1472                 p_dcb->max_rx_apdu_size         = p_echo_cfg->max_rx_apdu_size;
   1473                 p_dcb->max_tx_apdu_size         = p_echo_cfg->max_tx_apdu_size;
   1474 
   1475                 bta_hl_set_dch_chan_cfg(app_idx, mcl_idx, mdl_idx, p_data);
   1476             }
   1477             else
   1478             {
   1479                 rsp_code = MCA_RSP_CFG_REJ;
   1480             }
   1481         }
   1482         else
   1483 
   1484         {
   1485             p_dcb->in_use               = TRUE;
   1486             p_dcb->dch_oper             = BTA_HL_DCH_OP_REMOTE_CREATE;
   1487             p_dcb->local_mdep_id        = p_create_ind->dep_id  ;
   1488             p_dcb->local_mdep_cfg_idx   = mdep_cfg_idx;
   1489             p_dcb->local_cfg            = BTA_HL_DCH_CFG_UNKNOWN;
   1490             p_dcb->remote_cfg           = p_create_ind->cfg;
   1491             p_dcb->mdl_id               = p_create_ind->mdl_id;
   1492             p_dcb->mdl_cfg_idx_included = FALSE;
   1493             bta_hl_find_rxtx_apdu_size(app_idx, mdep_cfg_idx,
   1494                                        &p_dcb->max_rx_apdu_size,
   1495                                        &p_dcb->max_tx_apdu_size);
   1496             send_create_ind_evt = TRUE;
   1497         }
   1498     }
   1499     else
   1500     {
   1501         rsp_code = MCA_RSP_BAD_MDEP;
   1502     }
   1503 
   1504     if (send_create_ind_evt)
   1505     {
   1506         evt_data.dch_create_ind.mcl_handle =  p_mcb->mcl_handle;
   1507         evt_data.dch_create_ind.app_handle =  p_acb->app_handle;
   1508         evt_data.dch_create_ind.local_mdep_id = p_dcb->local_mdep_id;
   1509         evt_data.dch_create_ind.mdl_id = p_dcb->mdl_id;
   1510         evt_data.dch_create_ind.cfg = p_dcb->remote_cfg;
   1511         bdcpy(evt_data.dch_create_ind.bd_addr, p_mcb->bd_addr);
   1512         p_acb->p_cback(BTA_HL_DCH_CREATE_IND_EVT,(tBTA_HL *) &evt_data );
   1513     }
   1514     else
   1515     {
   1516         if (MCA_CreateMdlRsp((tMCA_CL) p_mcb->mcl_handle,
   1517                              p_dcb->local_mdep_id,
   1518                              p_dcb->mdl_id,
   1519                              p_dcb->local_cfg,
   1520                              rsp_code,
   1521                              &p_dcb->chnl_cfg)!= MCA_SUCCESS)
   1522         {
   1523             bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
   1524         }
   1525         else
   1526         {
   1527             if (p_dcb->local_mdep_id == BTA_HL_ECHO_TEST_MDEP_ID)
   1528             {
   1529                 p_mcb->echo_test = TRUE;
   1530                 p_dcb->echo_oper = BTA_HL_ECHO_OP_OPEN_IND;
   1531             }
   1532         }
   1533     }
   1534 }
   1535 
   1536 /*******************************************************************************
   1537 **
   1538 ** Function         bta_hl_dch_mca_create_cfm
   1539 **
   1540 ** Description      Action routine for processing
   1541 **
   1542 ** Returns          void
   1543 **
   1544 *******************************************************************************/
   1545 void bta_hl_dch_mca_create_cfm(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
   1546                                tBTA_HL_DATA *p_data)
   1547 {
   1548     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   1549     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
   1550     tMCA_CREATE_CFM     *p_create_cfm = &p_data->mca_evt.mca_data.create_cfm;
   1551 
   1552 #if (BTA_HL_DEBUG == TRUE)
   1553     APPL_TRACE_DEBUG0("bta_hl_dch_mca_create_cfm");
   1554 #endif
   1555 
   1556     if (p_dcb->abort_oper & BTA_HL_ABORT_PENDING_MASK)
   1557     {
   1558         p_dcb->abort_oper &= ~BTA_HL_ABORT_PENDING_MASK;
   1559         bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_ABORT_EVT, p_data);
   1560         return;
   1561     }
   1562 
   1563     if (p_dcb->dch_oper == BTA_HL_DCH_OP_LOCAL_OPEN)
   1564     {
   1565         if (p_create_cfm->rsp_code == MCA_RSP_SUCCESS)
   1566         {
   1567             if (bta_hl_validate_cfg(app_idx, mcl_idx, mdl_idx, p_create_cfm->cfg ))
   1568             {
   1569                 bta_hl_set_dch_chan_cfg(app_idx, mcl_idx, mdl_idx, p_data);
   1570 
   1571                 if (MCA_DataChnlCfg((tMCA_CL) p_mcb->mcl_handle, &p_dcb->chnl_cfg)!= MCA_SUCCESS)
   1572                 {
   1573                     /* this should not happen */
   1574                     APPL_TRACE_ERROR0("Unable to create data channel");
   1575                     MCA_Abort((tMCA_CL) p_mcb->mcl_handle);
   1576                     bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
   1577                 }
   1578                 else
   1579                 {
   1580                     if (p_dcb->local_mdep_id == BTA_HL_ECHO_TEST_MDEP_ID)
   1581                     {
   1582                         p_dcb->echo_oper = BTA_HL_ECHO_OP_DCH_OPEN_CFM;
   1583                     }
   1584                 }
   1585             }
   1586             else
   1587             {
   1588                 MCA_Abort((tMCA_CL) p_mcb->mcl_handle);
   1589                 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
   1590             }
   1591         }
   1592         else
   1593         {
   1594             APPL_TRACE_ERROR0("MCA Create- failed");
   1595             bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
   1596         }
   1597     }
   1598 }
   1599 
   1600 /*******************************************************************************
   1601 **
   1602 ** Function         bta_hl_dch_mca_create
   1603 **
   1604 ** Description      Action routine for processing the MDL create request
   1605 **
   1606 ** Returns          void
   1607 **
   1608 *******************************************************************************/
   1609 void bta_hl_dch_mca_create(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
   1610                            tBTA_HL_DATA *p_data)
   1611 {
   1612     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   1613     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
   1614     tMCA_RESULT         result;
   1615     UINT8               sdp_idx;
   1616 
   1617 #if BTA_HL_DEBUG == TRUE
   1618     APPL_TRACE_DEBUG0("bta_hl_dch_mca_create");
   1619 #endif
   1620 
   1621     if (bta_hl_find_sdp_idx_using_ctrl_psm(&p_mcb->sdp, p_mcb->ctrl_psm, &sdp_idx) &&
   1622         bta_hl_validate_peer_cfg(app_idx, mcl_idx, mdl_idx,
   1623                                  p_dcb->peer_mdep_id,
   1624                                  p_dcb->peer_mdep_role,
   1625                                  sdp_idx))
   1626     {
   1627 
   1628         p_mcb->data_psm = p_mcb->sdp.sdp_rec[sdp_idx].data_psm;
   1629         if ( (result = MCA_CreateMdl((tMCA_CL) p_mcb->mcl_handle,
   1630                                      p_dcb->local_mdep_id,
   1631                                      p_mcb->data_psm,
   1632                                      p_dcb->mdl_id,
   1633                                      p_dcb->peer_mdep_id,
   1634                                      p_dcb->local_cfg,
   1635                                      NULL )) != MCA_SUCCESS)
   1636         {
   1637             APPL_TRACE_ERROR1("MCA_CreateMdl FAIL mca_result=%d", result);
   1638             bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
   1639         }
   1640     }
   1641     else
   1642     {
   1643         APPL_TRACE_ERROR0("MCA Create- SDP idx or peer MDEP cfg not found");
   1644         bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
   1645     }
   1646 }
   1647 
   1648 /*******************************************************************************
   1649 **
   1650 ** Function         bta_hl_dch_sdp_fail
   1651 **
   1652 ** Description      Action routine for processing the SDP failed event
   1653 **
   1654 ** Returns          void
   1655 **
   1656 *******************************************************************************/
   1657 void bta_hl_dch_sdp_fail(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
   1658                          tBTA_HL_DATA *p_data)
   1659 {
   1660 
   1661 #if (BTA_HL_DEBUG == TRUE)
   1662     APPL_TRACE_DEBUG0("bta_hl_dch_sdp_fail");
   1663 #endif
   1664     bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
   1665 }
   1666 
   1667 /******************************************************************************
   1668 **
   1669 ** Function         bta_hl_sdp_cback
   1670 **
   1671 ** Description      This is the SDP callback function used by HL.
   1672 **                  This function will be executed by SDP when the service
   1673 **                  search is completed.  If the search is successful, it
   1674 **                  finds the first record in the database that matches the
   1675 **                  UUID of the search.  Then retrieves the scn from the
   1676 **                  record.
   1677 **
   1678 ** Returns          void.
   1679 **
   1680 ******************************************************************************/
   1681 static void bta_hl_sdp_cback(UINT8 sdp_oper, UINT8 app_idx, UINT8 mcl_idx,
   1682                              UINT8 mdl_idx, UINT16 status)
   1683 {
   1684     tBTA_HL_MCL_CB                  *p_cb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   1685     tBTA_HL_SDP_REC                 *p_hdp_rec;
   1686     tBTA_HL_CCH_SDP                 *p_cch_buf;
   1687     tBTA_HL_DCH_SDP                 *p_dch_buf;
   1688     tSDP_DISC_REC                   *p_rec = NULL;
   1689     tSDP_PROTOCOL_ELEM              pe;
   1690     tSDP_DISC_ATTR                  *p_attr;
   1691     UINT8                           i, rec_cnt;
   1692     tBTA_HL_SUP_FEATURE_LIST_ELEM   sup_feature;
   1693     BOOLEAN                         sdp_parsing_ok =FALSE, result=FALSE;
   1694     UINT16                          event;
   1695     tBTA_HL_MDL_CB                  *p_dcb;
   1696     UINT16                          service_uuid;
   1697     UINT16                          name_len;
   1698 
   1699 #if BTA_HL_DEBUG == TRUE
   1700     APPL_TRACE_DEBUG5("bta_hl_sdp_cback status:%d sdp_oper=%d app_idx=%d, mcl_idx=%d,   mdl_idx=%d",
   1701                       status, sdp_oper, app_idx, mcl_idx, mdl_idx);
   1702 #endif
   1703 
   1704     rec_cnt = 0;
   1705     service_uuid = bta_hl_get_service_uuids(sdp_oper, app_idx, mcl_idx, mdl_idx);
   1706 
   1707     if (status == SDP_SUCCESS || status == SDP_DB_FULL)
   1708     {
   1709         memset(&p_cb->sdp,0, sizeof(tBTA_HL_SDP));
   1710         do
   1711         {
   1712             if (bta_hl_find_service_in_db(app_idx, mcl_idx, service_uuid, &p_rec))
   1713             {
   1714                 p_hdp_rec = &p_cb->sdp.sdp_rec[rec_cnt];
   1715                 p_cb->sdp.num_recs = rec_cnt+1;
   1716             }
   1717             else
   1718             {
   1719                 break;
   1720             }
   1721 
   1722             if (SDP_FindProtocolListElemInRec(p_rec, UUID_PROTOCOL_L2CAP, &pe))
   1723             {
   1724                 p_hdp_rec->ctrl_psm  = (UINT16) pe.params[0];
   1725             }
   1726             else
   1727             {
   1728                 APPL_TRACE_WARNING0("Control PSM not found");
   1729                 break;
   1730             }
   1731             if (SDP_FindAddProtoListsElemInRec(p_rec, UUID_PROTOCOL_L2CAP, &pe))
   1732             {
   1733                 p_hdp_rec->data_psm = (UINT16) pe.params[0];
   1734             }
   1735             else
   1736             {
   1737                 APPL_TRACE_WARNING0("Data PSM not found");
   1738                 break;
   1739             }
   1740 
   1741             p_hdp_rec->srv_name[0]= '\0';
   1742             if ((p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_SERVICE_NAME)) != NULL)
   1743             {
   1744                 if (SDP_DISC_ATTR_LEN(p_attr->attr_len_type) < BT_MAX_SERVICE_NAME_LEN)
   1745                     name_len = (UINT16)SDP_DISC_ATTR_LEN(p_attr->attr_len_type);
   1746                 else
   1747                     name_len = BT_MAX_SERVICE_NAME_LEN;
   1748                 memcpy(p_hdp_rec->srv_name, p_attr->attr_value.v.array, name_len);
   1749             }
   1750 
   1751             p_hdp_rec->srv_desp[0]= '\0';
   1752             if ((p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_SERVICE_DESCRIPTION)) != NULL)
   1753             {
   1754                 if (SDP_DISC_ATTR_LEN(p_attr->attr_len_type) < BT_MAX_SERVICE_NAME_LEN)
   1755                     name_len = (UINT16)SDP_DISC_ATTR_LEN(p_attr->attr_len_type);
   1756                 else
   1757                     name_len = BT_MAX_SERVICE_NAME_LEN;
   1758                 memcpy(p_hdp_rec->srv_desp, p_attr->attr_value.v.array, name_len);
   1759             }
   1760 
   1761 
   1762             p_hdp_rec->provider_name[0]= '\0';
   1763             if ((p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_PROVIDER_NAME)) != NULL)
   1764             {
   1765                 if (SDP_DISC_ATTR_LEN(p_attr->attr_len_type) < BT_MAX_SERVICE_NAME_LEN)
   1766                     name_len = (UINT16)SDP_DISC_ATTR_LEN(p_attr->attr_len_type);
   1767                 else
   1768                     name_len = BT_MAX_SERVICE_NAME_LEN;
   1769                 memcpy(p_hdp_rec->provider_name, p_attr->attr_value.v.array, name_len);
   1770             }
   1771 
   1772             if ((p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_HDP_MCAP_SUP_PROC))!=NULL)
   1773             {
   1774                 p_hdp_rec->mcap_sup_proc = p_attr->attr_value.v.u8;
   1775             }
   1776             else
   1777             {
   1778                 APPL_TRACE_WARNING0("MCAP SUP PROC not found");
   1779                 break;
   1780             }
   1781 
   1782             if ((p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_HDP_SUP_FEAT_LIST ))!=NULL)
   1783             {
   1784                 if (bta_hl_fill_sup_feature_list (p_attr, &sup_feature))
   1785                 {
   1786                     p_hdp_rec->num_mdeps = (UINT8) sup_feature.num_elems;
   1787                     APPL_TRACE_WARNING1("bta_hl_sdp_cback num_mdeps %d",sup_feature.num_elems);
   1788                     for (i=0; i<sup_feature.num_elems; i++)
   1789                     {
   1790                         p_hdp_rec->mdep_cfg[i].data_type = sup_feature.list_elem[i].data_type;
   1791                         p_hdp_rec->mdep_cfg[i].mdep_id = sup_feature.list_elem[i].mdep_id;
   1792                         p_hdp_rec->mdep_cfg[i].mdep_role = sup_feature.list_elem[i].mdep_role;
   1793                         /* Check MDEP Description pointer to prevent crash due to null pointer */
   1794                         if (sup_feature.list_elem[i].p_mdep_desp != NULL)
   1795                         {
   1796                             BCM_STRNCPY_S(p_hdp_rec->mdep_cfg[i].mdep_desp,
   1797                                     sizeof(p_hdp_rec->mdep_cfg[i].mdep_desp),
   1798                                     sup_feature.list_elem[i].p_mdep_desp,
   1799                                     BTA_HL_MDEP_DESP_LEN);
   1800                         }
   1801                         else
   1802                         {
   1803                             APPL_TRACE_ERROR1("bta_hl_sdp_cback Incorrect Mdep[%d] Description (Null ptr)", i);
   1804                         }
   1805                     }
   1806 
   1807                     sdp_parsing_ok = TRUE;
   1808                 }
   1809                 else
   1810                 {
   1811                     APPL_TRACE_WARNING0("HDP supported feature list fill failed");
   1812                     break;
   1813                 }
   1814             }
   1815             else
   1816             {
   1817                 APPL_TRACE_WARNING0("HDP supported feature list not found");
   1818                 break;
   1819             }
   1820 #if BTA_HL_DEBUG == TRUE
   1821             APPL_TRACE_DEBUG3("record=%d ctrl_psm=%0x data_psm=%x",
   1822                               rec_cnt+1,
   1823                               p_hdp_rec->ctrl_psm,
   1824                               p_hdp_rec->data_psm );
   1825             APPL_TRACE_DEBUG1("srv_name=[%s]",(p_hdp_rec->srv_name[0] != '\0')? p_hdp_rec->srv_name:"NULL");
   1826             APPL_TRACE_DEBUG1("srv_desp=[%s]",(p_hdp_rec->srv_desp[0] != '\0')? p_hdp_rec->srv_desp:"NULL");
   1827             for (i=0; i<sup_feature.num_elems; i++)
   1828             {
   1829                 APPL_TRACE_DEBUG5("index=0x%02x mdep_id=0x%04x data type=0x%04x mdep role=%s(0x%02x)",
   1830                                   (i+1),
   1831                                   p_hdp_rec->mdep_cfg[i].mdep_id,
   1832                                   p_hdp_rec->mdep_cfg[i].data_type,
   1833                                   (p_hdp_rec->mdep_cfg[i].mdep_role == BTA_HL_MDEP_ROLE_SOURCE)?"Src":"Snk",
   1834                                   p_hdp_rec->mdep_cfg[i].mdep_role);
   1835             }
   1836             APPL_TRACE_DEBUG1("provider_name=[%s]",(p_hdp_rec->provider_name[0] != '\0')? p_hdp_rec->provider_name:"NULL");
   1837             APPL_TRACE_DEBUG1("found MCAP sup procedure=%d",
   1838                               p_cb->sdp.sdp_rec[rec_cnt].mcap_sup_proc );
   1839 #endif
   1840             rec_cnt++;
   1841             if (rec_cnt >= BTA_HL_NUM_SDP_RECS)
   1842             {
   1843                 APPL_TRACE_WARNING1("No more spaces for SDP recs max_rec_cnt=%d", BTA_HL_NUM_SDP_RECS);
   1844                 break;
   1845             }
   1846 
   1847 
   1848         } while (TRUE);
   1849     }
   1850 
   1851 
   1852     utl_freebuf((void **)&p_cb->p_db);
   1853 
   1854     if ( (status == SDP_SUCCESS || status == SDP_DB_FULL) &&
   1855          p_cb->sdp.num_recs  &&
   1856          sdp_parsing_ok)
   1857     {
   1858         result = TRUE;
   1859     }
   1860     else
   1861     {
   1862         APPL_TRACE_WARNING3("SDP Failed sdp_status=%d num_recs=%d sdp_parsing_ok=%d ",
   1863                             status, p_cb->sdp.num_recs,sdp_parsing_ok );
   1864     }
   1865 
   1866 
   1867     p_cb->sdp_oper = BTA_HL_SDP_OP_NONE;
   1868 
   1869     switch (sdp_oper )
   1870     {
   1871         case BTA_HL_SDP_OP_CCH_INIT:
   1872         case BTA_HL_SDP_OP_SDP_QUERY_NEW:
   1873         case BTA_HL_SDP_OP_SDP_QUERY_CURRENT:
   1874 
   1875             /* send result in event back to BTA */
   1876             if ((p_cch_buf = (tBTA_HL_CCH_SDP *) GKI_getbuf(sizeof(tBTA_HL_CCH_SDP))) != NULL)
   1877             {
   1878                 if (result)
   1879                 {
   1880                     if (sdp_oper == BTA_HL_SDP_OP_CCH_INIT)
   1881                     {
   1882                         event = BTA_HL_CCH_SDP_OK_EVT;
   1883                         if (p_cb->close_pending)
   1884                         {
   1885                             event = BTA_HL_CCH_SDP_FAIL_EVT;
   1886                         }
   1887                     }
   1888                     else
   1889                     {
   1890                         event = BTA_HL_SDP_QUERY_OK_EVT;
   1891                     }
   1892                 }
   1893                 else
   1894                 {
   1895                     if (sdp_oper == BTA_HL_SDP_OP_CCH_INIT)
   1896                     {
   1897                         event = BTA_HL_CCH_SDP_FAIL_EVT;
   1898                     }
   1899                     else
   1900                     {
   1901                         event = BTA_HL_SDP_QUERY_FAIL_EVT;
   1902                     }
   1903                 }
   1904                 p_cch_buf->hdr.event = event;
   1905 
   1906                 p_cch_buf->app_idx = app_idx;
   1907                 p_cch_buf->mcl_idx = mcl_idx;
   1908                 p_cch_buf->release_mcl_cb = FALSE;
   1909                 if (sdp_oper == BTA_HL_SDP_OP_SDP_QUERY_NEW)
   1910                 {
   1911                     p_cch_buf->release_mcl_cb = TRUE;
   1912                 }
   1913 
   1914                 bta_sys_sendmsg(p_cch_buf);
   1915             }
   1916             break;
   1917         case BTA_HL_SDP_OP_DCH_OPEN_INIT:
   1918         case BTA_HL_SDP_OP_DCH_RECONNECT_INIT:
   1919             if ((p_dch_buf = (tBTA_HL_DCH_SDP *) GKI_getbuf(sizeof(tBTA_HL_DCH_SDP))) != NULL)
   1920             {
   1921                 p_dch_buf->hdr.event = BTA_HL_DCH_SDP_FAIL_EVT;
   1922                 p_dch_buf->app_idx = app_idx;
   1923                 p_dch_buf->mcl_idx = mcl_idx;
   1924                 p_dch_buf->mdl_idx = mdl_idx;
   1925                 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
   1926                 if (p_dcb->abort_oper & BTA_HL_ABORT_PENDING_MASK)
   1927                 {
   1928                     p_dcb->abort_oper &= ~BTA_HL_ABORT_PENDING_MASK;
   1929                     result = FALSE;
   1930                 }
   1931                 if (result)
   1932                 {
   1933                     if (sdp_oper == BTA_HL_SDP_OP_DCH_OPEN_INIT)
   1934                     {
   1935                         if (p_dcb->local_mdep_id == BTA_HL_ECHO_TEST_MDEP_ID )
   1936                         {
   1937                             p_dch_buf->hdr.event = BTA_HL_DCH_ECHO_TEST_EVT;
   1938                         }
   1939                         else
   1940                         {
   1941                             p_dch_buf->hdr.event = BTA_HL_DCH_OPEN_EVT;
   1942                         }
   1943                     }
   1944                     else
   1945                     {
   1946                         p_dch_buf->hdr.event = BTA_HL_DCH_RECONNECT_EVT;
   1947                     }
   1948                 }
   1949                 bta_sys_sendmsg(p_dch_buf);
   1950             }
   1951             break;
   1952         default:
   1953             break;
   1954     }
   1955 }
   1956 
   1957 
   1958 /******************************************************************************
   1959 **
   1960 ** Function         bta_hl_sdp_cback0
   1961 **
   1962 ** Description      This is the SDP callback function used by index = 0
   1963 **
   1964 ** Returns          void.
   1965 **
   1966 ******************************************************************************/
   1967 static void bta_hl_sdp_cback0(UINT16 status)
   1968 {
   1969     bta_hl_sdp_cback(bta_hl_cb.scb[0].sdp_oper,
   1970                      bta_hl_cb.scb[0].app_idx,
   1971                      bta_hl_cb.scb[0].mcl_idx,
   1972                      bta_hl_cb.scb[0].mdl_idx,
   1973                      status);
   1974     bta_hl_deallocate_spd_cback(0);
   1975 }
   1976 
   1977 /******************************************************************************
   1978 **
   1979 ** Function         bta_hl_sdp_cback1
   1980 **
   1981 ** Description      This is the SDP callback function used by index = 1
   1982 **
   1983 ** Parameters       status  - status of the SDP callabck
   1984 **
   1985 ** Returns          void.
   1986 **
   1987 ******************************************************************************/
   1988 static void bta_hl_sdp_cback1(UINT16 status)
   1989 {
   1990     bta_hl_sdp_cback(bta_hl_cb.scb[1].sdp_oper,
   1991                      bta_hl_cb.scb[1].app_idx,
   1992                      bta_hl_cb.scb[1].mcl_idx,
   1993                      bta_hl_cb.scb[1].mdl_idx,
   1994                      status);
   1995     bta_hl_deallocate_spd_cback(1);
   1996 }
   1997 
   1998 /******************************************************************************
   1999 **
   2000 ** Function         bta_hl_sdp_cback2
   2001 **
   2002 ** Description      This is the SDP callback function used by index = 2
   2003 **
   2004 ** Returns          void.
   2005 **
   2006 ******************************************************************************/
   2007 static void bta_hl_sdp_cback2(UINT16 status)
   2008 {
   2009     bta_hl_sdp_cback(bta_hl_cb.scb[2].sdp_oper,
   2010                      bta_hl_cb.scb[2].app_idx,
   2011                      bta_hl_cb.scb[2].mcl_idx,
   2012                      bta_hl_cb.scb[2].mdl_idx,
   2013                      status);
   2014     bta_hl_deallocate_spd_cback(2);
   2015 }
   2016 
   2017 /******************************************************************************
   2018 **
   2019 ** Function         bta_hl_sdp_cback3
   2020 **
   2021 ** Description      This is the SDP callback function used by index = 3
   2022 **
   2023 ** Returns          void.
   2024 **
   2025 ******************************************************************************/
   2026 static void bta_hl_sdp_cback3(UINT16 status)
   2027 {
   2028     bta_hl_sdp_cback(bta_hl_cb.scb[3].sdp_oper,
   2029                      bta_hl_cb.scb[3].app_idx,
   2030                      bta_hl_cb.scb[3].mcl_idx,
   2031                      bta_hl_cb.scb[3].mdl_idx,
   2032                      status);
   2033     bta_hl_deallocate_spd_cback(3);
   2034 }
   2035 
   2036 /******************************************************************************
   2037 **
   2038 ** Function         bta_hl_sdp_cback4
   2039 **
   2040 ** Description      This is the SDP callback function used by index = 4
   2041 **
   2042 ** Parameters       status  - status of the SDP callabck
   2043 **
   2044 ** Returns          void.
   2045 **
   2046 ******************************************************************************/
   2047 static void bta_hl_sdp_cback4(UINT16 status)
   2048 {
   2049     bta_hl_sdp_cback(bta_hl_cb.scb[4].sdp_oper,
   2050                      bta_hl_cb.scb[4].app_idx,
   2051                      bta_hl_cb.scb[4].mcl_idx,
   2052                      bta_hl_cb.scb[4].mdl_idx,
   2053                      status);
   2054     bta_hl_deallocate_spd_cback(4);
   2055 }
   2056 
   2057 /******************************************************************************
   2058 **
   2059 ** Function         bta_hl_sdp_cback5
   2060 **
   2061 ** Description      This is the SDP callback function used by index = 5
   2062 **
   2063 ** Parameters       status  - status of the SDP callabck
   2064 **
   2065 ** Returns          void.
   2066 **
   2067 ******************************************************************************/
   2068 static void bta_hl_sdp_cback5(UINT16 status)
   2069 {
   2070     bta_hl_sdp_cback(bta_hl_cb.scb[5].sdp_oper,
   2071                      bta_hl_cb.scb[5].app_idx,
   2072                      bta_hl_cb.scb[5].mcl_idx,
   2073                      bta_hl_cb.scb[5].mdl_idx,
   2074                      status);
   2075     bta_hl_deallocate_spd_cback(5);
   2076 }
   2077 
   2078 /******************************************************************************
   2079 **
   2080 ** Function         bta_hl_sdp_cback6
   2081 **
   2082 ** Description      This is the SDP callback function used by index = 6
   2083 **
   2084 ** Returns          void.
   2085 **
   2086 ******************************************************************************/
   2087 static void bta_hl_sdp_cback6(UINT16 status)
   2088 {
   2089     bta_hl_sdp_cback(bta_hl_cb.scb[6].sdp_oper,
   2090                      bta_hl_cb.scb[6].app_idx,
   2091                      bta_hl_cb.scb[6].mcl_idx,
   2092                      bta_hl_cb.scb[6].mdl_idx,
   2093                      status);
   2094     bta_hl_deallocate_spd_cback(6);
   2095 }
   2096 
   2097 
   2098 /*******************************************************************************
   2099 **
   2100 ** Function      bta_hl_deallocate_spd_cback
   2101 **
   2102 ** Description   Deallocate a SDP control block
   2103 **
   2104 ** Returns      BOOLEAN - TRUE found
   2105 **                        FALSE not found
   2106 **
   2107 *******************************************************************************/
   2108 void bta_hl_deallocate_spd_cback(UINT8 sdp_cback_idx)
   2109 {
   2110     tBTA_HL_SDP_CB *p_spd_cb = &bta_hl_cb.scb[sdp_cback_idx];
   2111 
   2112     memset(p_spd_cb, 0, sizeof(tBTA_HL_SDP_CB));
   2113 
   2114 #if BTA_HL_DEBUG == TRUE
   2115     APPL_TRACE_DEBUG1("bta_hl_deallocate_spd_cback index=%d", sdp_cback_idx);
   2116 #endif
   2117 
   2118 
   2119 }
   2120 
   2121 /*******************************************************************************
   2122 **
   2123 ** Function      bta_hl_allocate_spd_cback
   2124 **
   2125 ** Description   Finds a not in used SDP control block index
   2126 **
   2127 **
   2128 ** Returns      BOOLEAN - TRUE found
   2129 **                        FALSE not found
   2130 **
   2131 *******************************************************************************/
   2132 tSDP_DISC_CMPL_CB *bta_hl_allocate_spd_cback(tBTA_HL_SDP_OPER sdp_oper, UINT8 app_idx, UINT8 mcl_idx,
   2133                                              UINT8 mdl_idx,
   2134                                              UINT8 *p_sdp_cback_idx)
   2135 {
   2136     UINT8 i;
   2137     tSDP_DISC_CMPL_CB *p_cbcak=NULL;
   2138 
   2139 
   2140     for (i=0; i < BTA_HL_NUM_SDP_CBACKS ; i ++)
   2141     {
   2142         if (!bta_hl_cb.scb[i].in_use)
   2143         {
   2144             p_cbcak = bta_hl_sdp_cback_arr[i];
   2145             bta_hl_cb.scb[i].in_use = TRUE;
   2146             bta_hl_cb.scb[i].sdp_oper = sdp_oper;
   2147             bta_hl_cb.scb[i].app_idx = app_idx;
   2148             bta_hl_cb.scb[i].mcl_idx = mcl_idx;
   2149             bta_hl_cb.scb[i].mdl_idx = mdl_idx;
   2150             *p_sdp_cback_idx = i;
   2151             break;
   2152         }
   2153     }
   2154 
   2155     if (i == BTA_HL_NUM_SDP_CBACKS)
   2156     {
   2157         APPL_TRACE_WARNING0("No scb is available to allocate")
   2158     }
   2159     else
   2160     {
   2161 #if BTA_HL_DEBUG == TRUE
   2162     APPL_TRACE_DEBUG1("bta_hl_allocate_spd_cback cback_idx=%d ",i );
   2163     APPL_TRACE_DEBUG4("sdp_oper=%d, app_idx=%d, mcl_idx=%d,  mdl_idx=%d",
   2164                       bta_hl_cb.scb[i].sdp_oper,
   2165                       bta_hl_cb.scb[i].app_idx,
   2166                       bta_hl_cb.scb[i].mcl_idx,
   2167                       bta_hl_cb.scb[i].mdl_idx );
   2168 #endif
   2169     }
   2170     return p_cbcak;
   2171 }
   2172 
   2173 
   2174 /*******************************************************************************
   2175 **
   2176 ** Function         bta_hl_init_sdp
   2177 **
   2178 ** Description      Action routine for processing the SDP initiattion request
   2179 **
   2180 ** Returns          void
   2181 **
   2182 *******************************************************************************/
   2183 tBTA_HL_STATUS bta_hl_init_sdp(tBTA_HL_SDP_OPER sdp_oper, UINT8 app_idx, UINT8 mcl_idx,
   2184                                UINT8 mdl_idx)
   2185 {
   2186     tBTA_HL_MCL_CB      *p_cb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   2187     tSDP_UUID           uuid_list;
   2188     UINT16              attr_list[BTA_HL_NUM_SRCH_ATTR];
   2189     UINT16              num_attrs = BTA_HL_NUM_SRCH_ATTR;
   2190     tBTA_HL_STATUS      status;
   2191     UINT8               sdp_cback_idx;
   2192 #if BTA_HL_DEBUG == TRUE
   2193     APPL_TRACE_DEBUG4("bta_hl_init_sdp sdp_oper=%d app_idx=%d mcl_idx=%d, mdl_idx=%d",
   2194                       sdp_oper, app_idx, mcl_idx, mdl_idx);
   2195 #endif
   2196     if ((p_cb->sdp_cback = bta_hl_allocate_spd_cback(sdp_oper, app_idx, mcl_idx, mdl_idx, &sdp_cback_idx)) != NULL)
   2197     {
   2198         if ( p_cb->p_db ||
   2199              (!p_cb->p_db &&
   2200               (p_cb->p_db = (tSDP_DISCOVERY_DB *) GKI_getbuf(BTA_HL_DISC_SIZE)) != NULL))
   2201         {
   2202             attr_list[0] = ATTR_ID_SERVICE_CLASS_ID_LIST;
   2203             attr_list[1] = ATTR_ID_PROTOCOL_DESC_LIST;
   2204             attr_list[2] = ATTR_ID_BT_PROFILE_DESC_LIST;
   2205             attr_list[3] = ATTR_ID_ADDITION_PROTO_DESC_LISTS;
   2206             attr_list[4] = ATTR_ID_SERVICE_NAME;
   2207             attr_list[5] = ATTR_ID_SERVICE_DESCRIPTION;
   2208             attr_list[6] = ATTR_ID_PROVIDER_NAME;
   2209             attr_list[7] = ATTR_ID_HDP_SUP_FEAT_LIST;
   2210             attr_list[8] = ATTR_ID_HDP_DATA_EXCH_SPEC;
   2211             attr_list[9] = ATTR_ID_HDP_MCAP_SUP_PROC;
   2212 
   2213 
   2214             uuid_list.len = LEN_UUID_16;
   2215             uuid_list.uu.uuid16 = UUID_SERVCLASS_HDP_PROFILE;
   2216             SDP_InitDiscoveryDb(p_cb->p_db, BTA_HL_DISC_SIZE, 1, &uuid_list, num_attrs, attr_list);
   2217 
   2218             if (!SDP_ServiceSearchAttributeRequest(p_cb->bd_addr, p_cb->p_db, p_cb->sdp_cback))
   2219             {
   2220                 status = BTA_HL_STATUS_FAIL;
   2221             }
   2222             else
   2223             {
   2224                 status = BTA_HL_STATUS_OK;
   2225             }
   2226         }
   2227         else    /* No services available */
   2228         {
   2229             status = BTA_HL_STATUS_NO_RESOURCE;
   2230         }
   2231     }
   2232     else
   2233     {
   2234         status = BTA_HL_STATUS_SDP_NO_RESOURCE;
   2235     }
   2236 
   2237     if (status != BTA_HL_STATUS_OK)
   2238     {
   2239         utl_freebuf((void **)&p_cb->p_db);
   2240         if (status != BTA_HL_STATUS_SDP_NO_RESOURCE )
   2241         {
   2242             bta_hl_deallocate_spd_cback(sdp_cback_idx);
   2243         }
   2244     }
   2245 
   2246     return status;
   2247 }
   2248 
   2249 /*******************************************************************************
   2250 **
   2251 ** Function         bta_hl_cch_sdp_init
   2252 **
   2253 ** Description      Action routine for processing the CCH SDP init event
   2254 **
   2255 ** Returns          void
   2256 **
   2257 *******************************************************************************/
   2258 void bta_hl_cch_sdp_init(UINT8 app_idx, UINT8 mcl_idx,  tBTA_HL_DATA *p_data)
   2259 {
   2260     tBTA_HL_MCL_CB      *p_cb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   2261 #if BTA_HL_DEBUG == TRUE
   2262     APPL_TRACE_DEBUG0("bta_hl_cch_init_sdp");
   2263 #endif
   2264     if ( p_cb->sdp_oper == BTA_HL_SDP_OP_NONE)
   2265     {
   2266         p_cb->app_id = p_data->api_cch_open.app_id;
   2267         p_cb->sdp_oper = BTA_HL_SDP_OP_CCH_INIT;
   2268 
   2269         if (bta_hl_init_sdp( p_cb->sdp_oper, app_idx, mcl_idx, 0xFF) != BTA_HL_STATUS_OK)
   2270         {
   2271             p_cb->sdp_oper = BTA_HL_SDP_OP_NONE;
   2272             bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_SDP_FAIL_EVT, p_data);
   2273         }
   2274     }
   2275     else
   2276     {
   2277         APPL_TRACE_ERROR0("SDP in use");
   2278         bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_SDP_FAIL_EVT, p_data);
   2279     }
   2280 }
   2281 
   2282 /*******************************************************************************
   2283 **
   2284 ** Function         bta_hl_cch_mca_open
   2285 **
   2286 ** Description      Action routine for processing the CCH open request
   2287 **
   2288 ** Returns          void
   2289 **
   2290 *******************************************************************************/
   2291 void bta_hl_cch_mca_open(UINT8 app_idx, UINT8 mcl_idx,  tBTA_HL_DATA *p_data)
   2292 {
   2293     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
   2294     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   2295     UINT8               sdp_idx;
   2296 
   2297 #if BTA_HL_DEBUG == TRUE
   2298     APPL_TRACE_DEBUG0("bta_hl_cch_mca_open");
   2299 #endif
   2300 
   2301     if (bta_hl_find_sdp_idx_using_ctrl_psm(&p_mcb->sdp, p_mcb->req_ctrl_psm, &sdp_idx))
   2302     {
   2303         p_mcb->ctrl_psm = p_mcb->sdp.sdp_rec[sdp_idx].ctrl_psm;
   2304         p_mcb->data_psm = p_mcb->sdp.sdp_rec[sdp_idx].data_psm;
   2305         if ( MCA_ConnectReq((tMCA_HANDLE) p_acb->app_handle,
   2306                             p_mcb->bd_addr,
   2307                             p_mcb->ctrl_psm ,
   2308                             p_mcb->sec_mask) != MCA_SUCCESS)
   2309         {
   2310 
   2311             bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_CLOSE_CMPL_EVT, p_data);
   2312         }
   2313     }
   2314     else
   2315     {
   2316         bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_CLOSE_CMPL_EVT, p_data);
   2317     }
   2318 }
   2319 
   2320 /*******************************************************************************
   2321 **
   2322 ** Function         bta_hl_cch_mca_close
   2323 **
   2324 ** Description      Action routine for processing the CCH close request
   2325 **
   2326 ** Returns          void
   2327 **
   2328 *******************************************************************************/
   2329 void bta_hl_cch_mca_close(UINT8 app_idx, UINT8 mcl_idx,  tBTA_HL_DATA *p_data)
   2330 {
   2331     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   2332 
   2333 #if BTA_HL_DEBUG == TRUE
   2334     APPL_TRACE_DEBUG1("bta_hl_cch_mca_close mcl_handle=%d", p_mcb->mcl_handle);
   2335 #endif
   2336     if (p_mcb->sdp_oper != BTA_HL_SDP_OP_CCH_INIT)
   2337     {
   2338         if(p_mcb->mcl_handle)
   2339         {
   2340             if ( MCA_DisconnectReq((tMCA_HANDLE) p_mcb->mcl_handle) != MCA_SUCCESS)
   2341             {
   2342                 bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_CLOSE_CMPL_EVT, p_data);
   2343             }
   2344         }
   2345         else
   2346         {
   2347             p_mcb->close_pending = TRUE;
   2348             APPL_TRACE_DEBUG0("No valid mcl_handle to stop the CCH setup now so wait until CCH is up then close it" );
   2349         }
   2350     }
   2351     else
   2352     {
   2353         p_mcb->close_pending = TRUE;
   2354         APPL_TRACE_DEBUG0("can not stop the CCH setup becasue SDP is in progress so wait until it is done" );
   2355     }
   2356 }
   2357 
   2358 /*******************************************************************************
   2359 **
   2360 ** Function         bta_hl_cch_close_cmpl
   2361 **
   2362 ** Description      Action routine for processing the CCH close complete event
   2363 **
   2364 ** Returns          void
   2365 **
   2366 *******************************************************************************/
   2367 void bta_hl_cch_close_cmpl(UINT8 app_idx, UINT8 mcl_idx,  tBTA_HL_DATA *p_data)
   2368 {
   2369     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
   2370     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   2371 
   2372     tBTA_HL             evt_data;
   2373     tBTA_HL_EVT         event;
   2374     BOOLEAN             send_evt=TRUE;
   2375 #if BTA_HL_DEBUG == TRUE
   2376     APPL_TRACE_DEBUG0("bta_hl_cch_close_cmpl");
   2377 #endif
   2378     bta_sys_conn_close(BTA_ID_HL, p_acb->app_id, p_mcb->bd_addr);
   2379 
   2380     if (p_mcb->cch_oper == BTA_HL_CCH_OP_LOCAL_CLOSE && p_mcb->force_close_local_cch_opening)
   2381     {
   2382        p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_OPEN;
   2383        APPL_TRACE_DEBUG0("change cch_oper from BTA_HL_CCH_OP_LOCAL_CLOSE to BTA_HL_CCH_OP_LOCAL_OPEN");
   2384     }
   2385 
   2386     switch (p_mcb->cch_oper)
   2387     {
   2388         case BTA_HL_CCH_OP_LOCAL_OPEN:
   2389             bta_hl_build_cch_open_cfm(&evt_data,p_mcb->app_id,p_acb->app_handle,
   2390                                       p_mcb->mcl_handle,
   2391                                       p_mcb->bd_addr,
   2392                                       BTA_HL_STATUS_FAIL);
   2393             event = BTA_HL_CCH_OPEN_CFM_EVT;
   2394             break;
   2395         case BTA_HL_CCH_OP_LOCAL_CLOSE:
   2396             bta_hl_build_cch_close_cfm(&evt_data,  p_acb->app_handle,
   2397                                        p_mcb->mcl_handle,
   2398                                        BTA_HL_STATUS_OK);
   2399             event = BTA_HL_CCH_CLOSE_CFM_EVT;
   2400             break;
   2401         case BTA_HL_CCH_OP_REMOTE_CLOSE:
   2402             bta_hl_build_cch_close_ind(&evt_data,
   2403                                        p_acb->app_handle,
   2404                                        p_mcb->mcl_handle,
   2405                                        p_mcb->intentional_close);
   2406             event = BTA_HL_CCH_CLOSE_IND_EVT;
   2407             break;
   2408         default:
   2409             send_evt=FALSE;
   2410             break;
   2411     }
   2412 
   2413 
   2414     memset(p_mcb, 0 ,sizeof(tBTA_HL_MCL_CB));
   2415 
   2416     if (send_evt)p_acb->p_cback(event,(tBTA_HL *) &evt_data );
   2417 
   2418     bta_hl_check_deregistration(app_idx, p_data);
   2419 }
   2420 
   2421 /*******************************************************************************
   2422 **
   2423 ** Function         bta_hl_cch_mca_disconnect
   2424 **
   2425 ** Description      Action routine for processing the CCH disconnect indication
   2426 **
   2427 ** Returns          void
   2428 **
   2429 *******************************************************************************/
   2430 void bta_hl_cch_mca_disconnect(UINT8 app_idx, UINT8 mcl_idx,  tBTA_HL_DATA *p_data)
   2431 {
   2432 
   2433     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   2434     tBTA_HL_MDL_CB      *p_dcb;
   2435     UINT8              i;
   2436 #if BTA_HL_DEBUG == TRUE
   2437     APPL_TRACE_DEBUG0("bta_hl_cch_mca_disconnect");
   2438 #endif
   2439 
   2440     p_mcb->intentional_close = FALSE;
   2441     if (p_data->mca_evt.mca_data.disconnect_ind.reason == L2CAP_DISC_OK)
   2442     {
   2443         p_mcb->intentional_close = TRUE;
   2444     }
   2445 
   2446     for (i=0; i< BTA_HL_NUM_MDLS_PER_MCL; i++)
   2447     {
   2448         p_dcb= BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, i);
   2449         if (p_dcb->in_use && (p_dcb->dch_state != BTA_HL_DCH_IDLE_ST))
   2450         {
   2451             if (p_mcb->cch_oper == BTA_HL_CCH_OP_LOCAL_CLOSE )
   2452             {
   2453                 bta_hl_dch_sm_execute(app_idx, mcl_idx, i, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
   2454             }
   2455             else
   2456             {
   2457                 bta_hl_dch_sm_execute(app_idx, mcl_idx, i, BTA_HL_MCA_CLOSE_IND_EVT, p_data);
   2458             }
   2459         }
   2460     }
   2461     bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_CLOSE_CMPL_EVT, p_data);
   2462 }
   2463 
   2464 /*******************************************************************************
   2465 **
   2466 ** Function         bta_hl_cch_mca_disc_open
   2467 **
   2468 ** Description      Action routine for disconnect the just opened Control channel
   2469 **
   2470 ** Returns          void
   2471 **
   2472 *******************************************************************************/
   2473 void bta_hl_cch_mca_disc_open(UINT8 app_idx, UINT8 mcl_idx,  tBTA_HL_DATA *p_data)
   2474 {
   2475     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   2476 
   2477 #if BTA_HL_DEBUG == TRUE
   2478     APPL_TRACE_DEBUG2("bta_hl_cch_mca_disc_open mcl_handle=0x%x close_pending=%d", p_data->mca_evt.mcl_handle, p_mcb->close_pending );
   2479 #endif
   2480 
   2481     p_mcb->close_pending = FALSE;
   2482     p_mcb->mcl_handle = p_data->mca_evt.mcl_handle;
   2483     bta_hl_cch_mca_close(app_idx, mcl_idx, p_data);
   2484 }
   2485 
   2486 /*******************************************************************************
   2487 **
   2488 ** Function         bta_hl_cch_mca_rsp_tout
   2489 **
   2490 ** Description      Action routine for processing the MCAP response timeout
   2491 **
   2492 ** Returns          void
   2493 **
   2494 *******************************************************************************/
   2495 void bta_hl_cch_mca_rsp_tout(UINT8 app_idx, UINT8 mcl_idx,  tBTA_HL_DATA *p_data)
   2496 {
   2497 
   2498     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   2499 #if BTA_HL_DEBUG == TRUE
   2500     APPL_TRACE_DEBUG0("bta_hl_cch_mca_rsp_tout");
   2501 #endif
   2502 
   2503     p_mcb->rsp_tout = TRUE;
   2504 
   2505     bta_hl_check_cch_close(app_idx,mcl_idx,p_data,TRUE);
   2506 }
   2507 
   2508 /*******************************************************************************
   2509 **
   2510 ** Function         bta_hl_cch_mca_connect
   2511 **
   2512 ** Description      Action routine for processing the CCH connect indication
   2513 **
   2514 ** Returns          void
   2515 **
   2516 *******************************************************************************/
   2517 void bta_hl_cch_mca_connect(UINT8 app_idx, UINT8 mcl_idx,  tBTA_HL_DATA *p_data)
   2518 {
   2519     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
   2520     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
   2521     tBTA_HL             evt_data;
   2522     tBTA_HL_EVT         event;
   2523     BOOLEAN             send_event=TRUE;
   2524 
   2525 #if BTA_HL_DEBUG == TRUE
   2526     APPL_TRACE_DEBUG1("bta_hl_cch_mca_connect mcl_handle=%d ", p_data->mca_evt.mcl_handle);
   2527 #endif
   2528 
   2529     p_mcb->mcl_handle = p_data->mca_evt.mcl_handle;
   2530     bdcpy(p_mcb->bd_addr, p_data->mca_evt.mca_data.connect_ind.bd_addr);
   2531     p_mcb->cch_mtu = p_data->mca_evt.mca_data.connect_ind.mtu;
   2532 
   2533     bta_sys_conn_open(BTA_ID_HL, p_acb->app_id, p_mcb->bd_addr);
   2534     switch (p_mcb->cch_oper)
   2535     {
   2536         case BTA_HL_CCH_OP_LOCAL_OPEN:
   2537             bta_hl_build_cch_open_cfm(&evt_data, p_mcb->app_id,p_acb->app_handle,
   2538                                       p_mcb->mcl_handle,
   2539                                       p_mcb->bd_addr,
   2540                                       BTA_HL_STATUS_OK);
   2541             event = BTA_HL_CCH_OPEN_CFM_EVT;
   2542             break;
   2543         case BTA_HL_CCH_OP_REMOTE_OPEN:
   2544             bta_hl_build_cch_open_ind(&evt_data, p_acb->app_handle,
   2545                                       p_mcb->mcl_handle,
   2546                                       p_mcb->bd_addr);
   2547             event = BTA_HL_CCH_OPEN_IND_EVT;
   2548             break;
   2549         default:
   2550             send_event = FALSE;
   2551             break;
   2552     }
   2553 
   2554     p_mcb->cch_oper = BTA_HL_CCH_OP_NONE;
   2555     if (send_event) p_acb->p_cback(event,(tBTA_HL *) &evt_data );
   2556 }
   2557 
   2558 /*******************************************************************************
   2559 **
   2560 ** Function         bta_hl_mcap_ctrl_cback
   2561 **
   2562 ** Description      MCAP control callback function for HL.
   2563 **
   2564 ** Returns          void
   2565 **
   2566 *******************************************************************************/
   2567 void bta_hl_mcap_ctrl_cback (tMCA_HANDLE handle, tMCA_CL mcl, UINT8 event,
   2568                              tMCA_CTRL *p_data)
   2569 {
   2570     tBTA_HL_MCA_EVT * p_msg;
   2571     BOOLEAN send_event=TRUE;
   2572     UINT16 mca_event;
   2573 
   2574 #if (BTA_HL_DEBUG == TRUE)
   2575 #if (BT_TRACE_VERBOSE == TRUE)
   2576     APPL_TRACE_EVENT1("bta_hl_mcap_ctrl_cback event[%s]",bta_hl_mcap_evt_code(event));
   2577 #else
   2578     APPL_TRACE_EVENT1("bta_hl_mcap_ctrl_cback event[0x%02x]", event);
   2579 #endif
   2580 #endif
   2581 
   2582     switch (event)
   2583     {
   2584 
   2585         case MCA_CREATE_IND_EVT:
   2586             mca_event = (UINT16) BTA_HL_MCA_CREATE_IND_EVT;
   2587             break;
   2588         case MCA_CREATE_CFM_EVT:
   2589             mca_event = (UINT16) BTA_HL_MCA_CREATE_CFM_EVT;
   2590             break;
   2591         case MCA_RECONNECT_IND_EVT:
   2592             mca_event = (UINT16) BTA_HL_MCA_RECONNECT_IND_EVT;
   2593             break;
   2594         case MCA_RECONNECT_CFM_EVT:
   2595             mca_event = (UINT16) BTA_HL_MCA_RECONNECT_CFM_EVT;
   2596             break;
   2597         case MCA_ABORT_IND_EVT:
   2598             mca_event = (UINT16) BTA_HL_MCA_ABORT_IND_EVT;
   2599             break;
   2600         case MCA_ABORT_CFM_EVT:
   2601             mca_event = (UINT16) BTA_HL_MCA_ABORT_CFM_EVT;
   2602             break;
   2603         case MCA_DELETE_IND_EVT:
   2604             mca_event = (UINT16) BTA_HL_MCA_DELETE_IND_EVT;
   2605             break;
   2606         case MCA_DELETE_CFM_EVT:
   2607             mca_event = (UINT16) BTA_HL_MCA_DELETE_CFM_EVT;
   2608             break;
   2609         case MCA_CONNECT_IND_EVT:
   2610             mca_event = (UINT16) BTA_HL_MCA_CONNECT_IND_EVT;
   2611             break;
   2612         case MCA_DISCONNECT_IND_EVT:
   2613             mca_event = (UINT16) BTA_HL_MCA_DISCONNECT_IND_EVT;
   2614             break;
   2615         case MCA_OPEN_IND_EVT:
   2616             mca_event = (UINT16) BTA_HL_MCA_OPEN_IND_EVT;
   2617             break;
   2618         case MCA_OPEN_CFM_EVT:
   2619             mca_event = (UINT16) BTA_HL_MCA_OPEN_CFM_EVT;
   2620             break;
   2621         case MCA_CLOSE_IND_EVT:
   2622             mca_event = (UINT16) BTA_HL_MCA_CLOSE_IND_EVT;
   2623             break;
   2624         case MCA_CLOSE_CFM_EVT:
   2625             mca_event = (UINT16) BTA_HL_MCA_CLOSE_CFM_EVT;
   2626             break;
   2627         case MCA_CONG_CHG_EVT:
   2628             mca_event = (UINT16) BTA_HL_MCA_CONG_CHG_EVT;
   2629             break;
   2630         case MCA_RSP_TOUT_IND_EVT:
   2631             mca_event = (UINT16) BTA_HL_MCA_RSP_TOUT_IND_EVT;
   2632             break;
   2633         case MCA_ERROR_RSP_EVT:
   2634 
   2635         default:
   2636             send_event=FALSE;
   2637             break;
   2638     }
   2639 
   2640     if (send_event && ((p_msg = (tBTA_HL_MCA_EVT *)GKI_getbuf(sizeof(tBTA_HL_MCA_EVT))) != NULL))
   2641     {
   2642         p_msg->hdr.event = mca_event;
   2643         p_msg->app_handle = (tBTA_HL_APP_HANDLE) handle;
   2644         p_msg->mcl_handle = (tBTA_HL_MCL_HANDLE) mcl;
   2645         memcpy (&p_msg->mca_data, p_data, sizeof(tMCA_CTRL));
   2646         bta_sys_sendmsg(p_msg);
   2647     }
   2648 }
   2649 
   2650 /*******************************************************************************
   2651 **
   2652 ** Function         bta_hl_mcap_data_cback
   2653 **
   2654 ** Description      MCAP data callback function for HL.
   2655 **
   2656 ** Returns          void
   2657 **
   2658 *******************************************************************************/
   2659 void bta_hl_mcap_data_cback (tMCA_DL mdl, BT_HDR *p_pkt)
   2660 {
   2661     tBTA_HL_MCA_RCV_DATA_EVT *p_msg;
   2662 
   2663     UINT8 app_idx, mcl_idx, mdl_idx;
   2664     if (bta_hl_find_mdl_idx_using_handle ((tBTA_HL_MDL_HANDLE)mdl, &app_idx, &mcl_idx, &mdl_idx))
   2665     {
   2666         if ((p_msg = (tBTA_HL_MCA_RCV_DATA_EVT *)GKI_getbuf(sizeof(tBTA_HL_MCA_RCV_DATA_EVT))) != NULL)
   2667         {
   2668             p_msg->hdr.event = BTA_HL_MCA_RCV_DATA_EVT;
   2669             p_msg->app_idx = app_idx;
   2670             p_msg->mcl_idx = mcl_idx;
   2671             p_msg->mdl_idx = mdl_idx;
   2672             p_msg->p_pkt = p_pkt;
   2673             bta_sys_sendmsg(p_msg);
   2674         }
   2675     }
   2676 }
   2677 /*****************************************************************************
   2678 **  Debug Functions
   2679 *****************************************************************************/
   2680 #if (BTA_HL_DEBUG == TRUE && BT_TRACE_VERBOSE == TRUE)
   2681 
   2682 /*******************************************************************************
   2683 **
   2684 ** Function         bta_hl_mcap_evt_code
   2685 **
   2686 ** Description      get the MCAP event string pointer
   2687 **
   2688 ** Returns          char * - event string pointer
   2689 **
   2690 *******************************************************************************/
   2691 static char *bta_hl_mcap_evt_code(UINT8 evt_code)
   2692 {
   2693 
   2694     switch (evt_code)
   2695     {
   2696 
   2697         case MCA_ERROR_RSP_EVT:
   2698             return "MCA_ERROR_RSP_EVT";
   2699         case MCA_CREATE_IND_EVT:
   2700             return "MCA_CREATE_IND_EVT";
   2701         case MCA_CREATE_CFM_EVT:
   2702             return "MCA_CREATE_CFM_EVT";
   2703         case MCA_RECONNECT_IND_EVT:
   2704             return "MCA_RECONNECT_IND_EVT";
   2705         case MCA_RECONNECT_CFM_EVT:
   2706             return "MCA_RECONNECT_CFM_EVT";
   2707         case MCA_ABORT_IND_EVT:
   2708             return "MCA_ABORT_IND_EVT";
   2709         case MCA_ABORT_CFM_EVT:
   2710             return "MCA_ABORT_CFM_EVT";
   2711         case MCA_DELETE_IND_EVT:
   2712             return "MCA_DELETE_IND_EVT";
   2713         case MCA_DELETE_CFM_EVT:
   2714             return "MCA_DELETE_CFM_EVT";
   2715 
   2716         case MCA_CONNECT_IND_EVT:
   2717             return "MCA_CONNECT_IND_EVT";
   2718         case MCA_DISCONNECT_IND_EVT:
   2719             return "MCA_DISCONNECT_IND_EVT";
   2720         case MCA_OPEN_IND_EVT:
   2721             return "MCA_OPEN_IND_EVT";
   2722         case MCA_OPEN_CFM_EVT:
   2723             return "MCA_OPEN_CFM_EVT";
   2724         case MCA_CLOSE_IND_EVT:
   2725             return "MCA_CLOSE_IND_EVT";
   2726         case MCA_CLOSE_CFM_EVT:
   2727             return "MCA_CLOSE_CFM_EVT";
   2728         case MCA_CONG_CHG_EVT:
   2729             return "MCA_CONG_CHG_EVT";
   2730         case MCA_RSP_TOUT_IND_EVT:
   2731             return "MCA_RSP_TOUT_IND_EVT";
   2732         default:
   2733             return "Unknown MCAP event code";
   2734     }
   2735 }
   2736 
   2737 
   2738 /*******************************************************************************
   2739 **
   2740 ** Function         bta_hl_cback_evt_code
   2741 **
   2742 ** Description      get the HDP event string pointer
   2743 **
   2744 ** Returns          char * - event string pointer
   2745 **
   2746 *******************************************************************************/
   2747 static char *bta_hl_cback_evt_code(UINT8 evt_code)
   2748 {
   2749 
   2750     switch (evt_code)
   2751     {
   2752 
   2753         case BTA_HL_CCH_OPEN_IND_EVT:
   2754             return "BTA_HL_CCH_OPEN_IND_EVT";
   2755         case BTA_HL_CCH_OPEN_CFM_EVT:
   2756             return "BTA_HL_CCH_OPEN_CFM_EVT";
   2757         case BTA_HL_CCH_CLOSE_IND_EVT:
   2758             return "BTA_HL_CCH_CLOSE_IND_EVT";
   2759         case     BTA_HL_CCH_CLOSE_CFM_EVT:
   2760             return "BTA_HL_CCH_CLOSE_CFM_EVT";
   2761         case BTA_HL_DCH_OPEN_IND_EVT:
   2762             return "BTA_HL_DCH_OPEN_IND_EVT";
   2763         case BTA_HL_DCH_OPEN_CFM_EVT:
   2764             return "BTA_HL_DCH_OPEN_CFM_EVT";
   2765         case BTA_HL_DCH_CLOSE_IND_EVT:
   2766             return "BTA_HL_DCH_CLOSE_IND_EVT";
   2767         case BTA_HL_DCH_CLOSE_CFM_EVT:
   2768             return "BTA_HL_DCH_CLOSE_CFM_EVT";
   2769         case BTA_HL_DCH_RCV_DATA_IND_EVT:
   2770             return "BTA_HL_DCH_RCV_DATA_IND_EVT";
   2771         case BTA_HL_REGISTER_CFM_EVT:
   2772             return "BTA_HL_REGISTER_CFM_EVT";
   2773         case BTA_HL_DEREGISTER_CFM_EVT:
   2774             return "BTA_HL_DEREGISTER_CFM_EVT";
   2775         case BTA_HL_DCH_RECONNECT_CFM_EVT:
   2776             return "BTA_HL_DCH_RECONNECT_CFM_EVT";
   2777         case BTA_HL_DCH_RECONNECT_IND_EVT:
   2778             return "BTA_HL_DCH_RECONNECT_IND_EVT";
   2779         case BTA_HL_DCH_ECHO_TEST_CFM_EVT:
   2780             return "BTA_HL_DCH_ECHO_TEST_CFM_EVT";
   2781         case BTA_HL_SDP_QUERY_CFM_EVT:
   2782             return "BTA_HL_SDP_QUERY_CFM_EVT";
   2783         case BTA_HL_CONG_CHG_IND_EVT:
   2784             return "BTA_HL_CONG_CHG_IND_EVT";
   2785         case BTA_HL_DCH_CREATE_IND_EVT:
   2786             return "BTA_HL_DCH_CREATE_IND_EVT";
   2787         case BTA_HL_DELETE_MDL_IND_EVT:
   2788             return "BTA_HL_DELETE_MDL_IND_EVT";
   2789         case BTA_HL_DELETE_MDL_CFM_EVT:
   2790             return "BTA_HL_DELETE_MDL_CFM_EVT";
   2791         case BTA_HL_DCH_ABORT_IND_EVT:
   2792             return "BTA_HL_DCH_ABORT_IND_EVT";
   2793         case BTA_HL_DCH_ABORT_CFM_EVT:
   2794             return "BTA_HL_DCH_ABORT_CFM_EVT";
   2795         default:
   2796             return "Unknown HDP event code";
   2797     }
   2798 }
   2799 
   2800 
   2801 
   2802 /*******************************************************************************
   2803 **
   2804 ** Function         bta_hl_dch_oper_code
   2805 **
   2806 ** Description      Get the DCH operation string
   2807 **
   2808 ** Returns          char * - DCH operation string pointer
   2809 **
   2810 *******************************************************************************/
   2811 static char *bta_hl_dch_oper_code(tBTA_HL_DCH_OPER oper_code)
   2812 {
   2813 
   2814     switch (oper_code)
   2815     {
   2816         case BTA_HL_DCH_OP_NONE:
   2817             return "BTA_HL_DCH_OP_NONE";
   2818         case BTA_HL_DCH_OP_REMOTE_CREATE:
   2819             return "BTA_HL_DCH_OP_REMOTE_CREATE";
   2820         case BTA_HL_DCH_OP_LOCAL_OPEN:
   2821             return "BTA_HL_DCH_OP_LOCAL_OPEN";
   2822         case BTA_HL_DCH_OP_REMOTE_OPEN:
   2823             return "BTA_HL_DCH_OP_REMOTE_OPEN";
   2824         case BTA_HL_DCH_OP_LOCAL_CLOSE:
   2825             return "BTA_HL_DCH_OP_LOCAL_CLOSE";
   2826         case BTA_HL_DCH_OP_REMOTE_CLOSE:
   2827             return "BTA_HL_DCH_OP_REMOTE_CLOSE";
   2828         case BTA_HL_DCH_OP_LOCAL_DELETE:
   2829             return "BTA_HL_DCH_OP_LOCAL_DELETE";
   2830         case BTA_HL_DCH_OP_REMOTE_DELETE:
   2831             return "BTA_HL_DCH_OP_REMOTE_DELETE";
   2832         case BTA_HL_DCH_OP_LOCAL_RECONNECT:
   2833             return "BTA_HL_DCH_OP_LOCAL_RECONNECT";
   2834         case BTA_HL_DCH_OP_REMOTE_RECONNECT:
   2835             return "BTA_HL_DCH_OP_REMOTE_RECONNECT";
   2836         case BTA_HL_DCH_OP_LOCAL_CLOSE_ECHO_TEST:
   2837             return "BTA_HL_DCH_OP_LOCAL_CLOSE_ECHO_TEST";
   2838         case BTA_HL_DCH_OP_LOCAL_CLOSE_RECONNECT:
   2839             return "BTA_HL_DCH_OP_LOCAL_CLOSE_RECONNECT";
   2840         default:
   2841             return "Unknown DCH oper code";
   2842     }
   2843 }
   2844 
   2845 
   2846 #endif  /* Debug Functions */
   2847 #endif /* HL_INCLUDED */
   2848