1 /******************************************************************************
3 * Copyright (C) 2003-2012 Broadcom Corporation
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:
9 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 ******************************************************************************/
19 /******************************************************************************
21 * This file implements utility functions for the HeaLth device profile
24 ******************************************************************************/
29 #include "bt_target.h"
30 #if defined(HL_INCLUDED) && (HL_INCLUDED == TRUE)
35 #include "bta_hl_int.h"
36 #include "bta_hl_co.h"
41 /*******************************************************************************
43 ** Function bta_hl_set_ctrl_psm_for_dch
45 ** Description This function set the control PSM for the DCH setup
47 ** Returns BOOLEAN - TRUE - control PSM setting is successful
48 *******************************************************************************/
49 BOOLEAN bta_hl_set_ctrl_psm_for_dch(UINT8 app_idx, UINT8 mcl_idx,
50 UINT8 mdl_idx, UINT16 ctrl_psm)
52 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
53 BOOLEAN success = TRUE, update_ctrl_psm = FALSE;
56 if (p_mcb->sdp.num_recs)
58 if (p_mcb->ctrl_psm != ctrl_psm)
60 /* can not use a different ctrl PSM than the current one*/
66 /* No SDP info control i.e. channel was opened by the peer */
67 update_ctrl_psm = TRUE;
70 if (success && update_ctrl_psm)
72 p_mcb->ctrl_psm = ctrl_psm;
76 #if BTA_HL_DEBUG == TRUE
79 APPL_TRACE_DEBUG("bta_hl_set_ctrl_psm_for_dch num_recs=%d success=%d update_ctrl_psm=%d ctrl_psm=0x%x ",
80 p_mcb->sdp.num_recs, success, update_ctrl_psm, ctrl_psm );
88 /*******************************************************************************
90 ** Function bta_hl_find_sdp_idx_using_ctrl_psm
94 ** Returns UINT8 pool_id
96 *******************************************************************************/
97 BOOLEAN bta_hl_find_sdp_idx_using_ctrl_psm(tBTA_HL_SDP *p_sdp,
102 tBTA_HL_SDP_REC *p_rec;
107 for (i=0; i<p_sdp->num_recs; i++)
109 p_rec = &p_sdp->sdp_rec[i];
110 if (p_rec->ctrl_psm == ctrl_psm)
124 #if BTA_HL_DEBUG == TRUE
127 APPL_TRACE_DEBUG("bta_hl_find_sdp_idx_using_ctrl_psm found=%d sdp_idx=%d ctrl_psm=0x%x ",
128 found, *p_sdp_idx, ctrl_psm );
134 /*******************************************************************************
136 ** Function bta_hl_set_user_tx_pool_id
138 ** Description This function sets the user tx pool id
140 ** Returns UINT8 pool_id
142 *******************************************************************************/
144 UINT8 bta_hl_set_user_tx_pool_id(UINT16 max_tx_size)
148 if (max_tx_size > GKI_get_pool_bufsize (HCI_ACL_POOL_ID))
150 pool_id = BTA_HL_LRG_DATA_POOL_ID;
154 pool_id = L2CAP_DEFAULT_ERM_POOL_ID;
157 #if BTA_HL_DEBUG == TRUE
158 APPL_TRACE_DEBUG("bta_hl_set_user_rx_pool_id pool_id=%d max_tx_size=%d default_ertm_pool_size=%d",
159 pool_id, max_tx_size, GKI_get_pool_bufsize (HCI_ACL_POOL_ID));
165 /*******************************************************************************
167 ** Function bta_hl_set_user_rx_pool_id
169 ** Description This function sets the user trx pool id
171 ** Returns UINT8 pool_id
173 *******************************************************************************/
175 UINT8 bta_hl_set_user_rx_pool_id(UINT16 mtu)
179 if (mtu > GKI_get_pool_bufsize (HCI_ACL_POOL_ID))
181 pool_id = BTA_HL_LRG_DATA_POOL_ID;
185 pool_id = L2CAP_DEFAULT_ERM_POOL_ID;
188 #if BTA_HL_DEBUG == TRUE
189 APPL_TRACE_DEBUG("bta_hl_set_user_rx_pool_id pool_id=%d mtu=%d default_ertm_pool_size=%d",
190 pool_id, mtu, GKI_get_pool_bufsize (HCI_ACL_POOL_ID));
198 /*******************************************************************************
200 ** Function bta_hl_set_tx_win_size
202 ** Description This function sets the tx window size
204 ** Returns UINT8 tx_win_size
206 *******************************************************************************/
207 UINT8 bta_hl_set_tx_win_size(UINT16 mtu, UINT16 mps)
219 tx_win_size = (mtu/mps)+1;
223 APPL_TRACE_ERROR("The MPS is zero");
228 #if BTA_HL_DEBUG == TRUE
229 APPL_TRACE_DEBUG("bta_hl_set_tx_win_size win_size=%d mtu=%d mps=%d",
230 tx_win_size, mtu, mps);
235 /*******************************************************************************
237 ** Function bta_hl_set_mps
239 ** Description This function sets the MPS
241 ** Returns UINT16 MPS
243 *******************************************************************************/
244 UINT16 bta_hl_set_mps(UINT16 mtu)
247 if (mtu > BTA_HL_L2C_MPS)
249 mps = BTA_HL_L2C_MPS;
255 #if BTA_HL_DEBUG == TRUE
256 APPL_TRACE_DEBUG("bta_hl_set_mps mps=%d mtu=%d",
263 /*******************************************************************************
265 ** Function bta_hl_clean_mdl_cb
267 ** Description This function clean up the specified MDL control block
271 *******************************************************************************/
272 void bta_hl_clean_mdl_cb(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx)
274 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
275 #if BTA_HL_DEBUG == TRUE
276 APPL_TRACE_DEBUG("bta_hl_clean_mdl_cb app_idx=%d mcl_idx=%d mdl_idx=%d",
277 app_idx, mcl_idx, mdl_idx);
279 utl_freebuf((void **) &p_dcb->p_tx_pkt);
280 utl_freebuf((void **) &p_dcb->p_rx_pkt);
281 utl_freebuf((void **) &p_dcb->p_echo_tx_pkt);
282 utl_freebuf((void **) &p_dcb->p_echo_rx_pkt);
284 memset((void *)p_dcb, 0 , sizeof(tBTA_HL_MDL_CB));
288 /*******************************************************************************
290 ** Function bta_hl_get_buf
292 ** Description This function allocate a buffer based on the specified data size
296 *******************************************************************************/
297 BT_HDR * bta_hl_get_buf(UINT16 data_size)
300 UINT16 size = data_size + L2CAP_MIN_OFFSET + BT_HDR_SIZE;
302 if (size < GKI_MAX_BUF_SIZE)
304 p_new = (BT_HDR *)GKI_getbuf(size);
308 p_new = (BT_HDR *) GKI_getpoolbuf(BTA_HL_LRG_DATA_POOL_ID);
313 p_new->len = data_size;
314 p_new->offset = L2CAP_MIN_OFFSET;
320 /*******************************************************************************
322 ** Function bta_hl_find_service_in_db
324 ** Description This function check the specified service class(es) can be find in
325 ** the received SDP database
327 ** Returns BOOLEAN TRUE - found
330 *******************************************************************************/
331 BOOLEAN bta_hl_find_service_in_db( UINT8 app_idx, UINT8 mcl_idx,
333 tSDP_DISC_REC **pp_rec )
335 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
336 BOOLEAN found = TRUE;
338 switch (service_uuid)
340 case UUID_SERVCLASS_HDP_SINK:
341 case UUID_SERVCLASS_HDP_SOURCE:
342 if ((*pp_rec = SDP_FindServiceInDb(p_mcb->p_db, service_uuid,
349 if (((*pp_rec = bta_hl_find_sink_or_src_srv_class_in_db(p_mcb->p_db,
359 /*******************************************************************************
361 ** Function bta_hl_get_service_uuids
364 ** Description This function finds the service class(es) for both CCH and DCH oeprations
366 ** Returns UINT16 - service_id
367 ** if service_uuid = 0xFFFF then it means service uuid
368 ** can be either Sink or Source
370 *******************************************************************************/
371 UINT16 bta_hl_get_service_uuids(UINT8 sdp_oper, UINT8 app_idx, UINT8 mcl_idx,
374 tBTA_HL_MDL_CB *p_dcb;
375 UINT16 service_uuid = 0xFFFF; /* both Sink and Source */
380 case BTA_HL_SDP_OP_DCH_OPEN_INIT:
381 case BTA_HL_SDP_OP_DCH_RECONNECT_INIT:
382 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
383 if (p_dcb->local_mdep_id != BTA_HL_ECHO_TEST_MDEP_ID)
385 if (p_dcb->peer_mdep_role == BTA_HL_MDEP_ROLE_SINK)
387 service_uuid = UUID_SERVCLASS_HDP_SINK;
391 service_uuid = UUID_SERVCLASS_HDP_SOURCE;
395 case BTA_HL_SDP_OP_CCH_INIT:
397 /* use default that is both Sink and Source */
400 #if BTA_HL_DEBUG == TRUE
401 APPL_TRACE_DEBUG("bta_hl_get_service_uuids service_uuid=0x%x",service_uuid );
406 /*******************************************************************************
408 ** Function bta_hl_find_echo_cfg_rsp
411 ** Description This function finds the configuration response for the echo test
413 ** Returns BOOLEAN - TRUE found
416 *******************************************************************************/
417 BOOLEAN bta_hl_find_echo_cfg_rsp(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdep_idx, UINT8 cfg,
420 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
421 tBTA_HL_MDEP *p_mdep= &p_acb->sup_feature.mdep[mdep_idx];
422 BOOLEAN status =TRUE;
424 if (p_mdep->mdep_id == BTA_HL_ECHO_TEST_MDEP_ID)
426 if ((cfg == BTA_HL_DCH_CFG_RELIABLE) || (cfg == BTA_HL_DCH_CFG_STREAMING))
430 else if (cfg == BTA_HL_DCH_CFG_NO_PREF )
432 *p_cfg_rsp = BTA_HL_DEFAULT_ECHO_TEST_SRC_DCH_CFG;
437 APPL_TRACE_ERROR("Inavlid echo cfg value");
442 #if BTA_HL_DEBUG == TRUE
445 APPL_TRACE_DEBUG("bta_hl_find_echo_cfg_rsp status=failed app_idx=%d mcl_idx=%d mdep_idx=%d cfg=%d",
446 app_idx, mcl_idx, mdep_idx, cfg);
453 /*******************************************************************************
455 ** Function bta_hl_validate_dch_cfg
457 ** Description This function validate the DCH configuration
459 ** Returns BOOLEAN - TRUE cfg is valid
462 *******************************************************************************/
463 BOOLEAN bta_hl_validate_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
466 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
467 BOOLEAN is_valid =FALSE;
470 if (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx) &&
471 (cfg != BTA_HL_DCH_CFG_RELIABLE))
473 APPL_TRACE_ERROR("the first DCH should be a reliable channel");
477 switch (p_dcb->local_cfg)
479 case BTA_HL_DCH_CFG_NO_PREF:
481 if ((cfg == BTA_HL_DCH_CFG_RELIABLE) || (cfg == BTA_HL_DCH_CFG_STREAMING))
486 case BTA_HL_DCH_CFG_RELIABLE:
487 case BTA_HL_DCH_CFG_STREAMING:
488 if (p_dcb->local_cfg == cfg )
497 #if BTA_HL_DEBUG == TRUE
500 APPL_TRACE_DEBUG("bta_hl_validate_dch_open_cfg is_valid=%d, cfg=%d", is_valid, cfg );
506 /*******************************************************************************
508 ** Function bta_hl_find_cch_cb_indexes
510 ** Description This function finds the indexes needed for the CCH state machine
512 ** Returns BOOLEAN - TRUE found
515 *******************************************************************************/
516 BOOLEAN bta_hl_find_cch_cb_indexes(tBTA_HL_DATA *p_msg,
520 BOOLEAN found = FALSE;
521 tBTA_HL_MCL_CB *p_mcb;
522 UINT8 app_idx = 0, mcl_idx = 0;
524 switch (p_msg->hdr.event)
526 case BTA_HL_CCH_SDP_OK_EVT:
527 case BTA_HL_CCH_SDP_FAIL_EVT:
528 app_idx = p_msg->cch_sdp.app_idx;
529 mcl_idx = p_msg->cch_sdp.mcl_idx;
533 case BTA_HL_MCA_CONNECT_IND_EVT:
535 if (bta_hl_find_app_idx_using_handle(p_msg->mca_evt.app_handle, &app_idx))
537 if (bta_hl_find_mcl_idx(app_idx, p_msg->mca_evt.mca_data.connect_ind.bd_addr, &mcl_idx))
539 /* local initiated */
542 else if (!bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx)&&
543 bta_hl_find_avail_mcl_idx(app_idx, &mcl_idx))
545 /* remote initiated */
546 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
547 p_mcb->in_use = TRUE;
548 p_mcb->cch_oper = BTA_HL_CCH_OP_REMOTE_OPEN;
554 case BTA_HL_MCA_DISCONNECT_IND_EVT:
556 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx))
560 else if (bta_hl_find_app_idx_using_handle(p_msg->mca_evt.app_handle, &app_idx) &&
561 bta_hl_find_mcl_idx(app_idx, p_msg->mca_evt.mca_data.disconnect_ind.bd_addr, &mcl_idx))
568 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
569 if ((p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_CLOSE) && (p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_OPEN) )
571 p_mcb->cch_oper = BTA_HL_CCH_OP_REMOTE_CLOSE;
576 case BTA_HL_MCA_RSP_TOUT_IND_EVT:
578 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx))
585 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
586 if ((p_mcb->cch_oper != BTA_HL_CCH_OP_REMOTE_CLOSE) && (p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_OPEN))
588 p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_CLOSE;
599 *p_app_idx = app_idx;
600 *p_mcl_idx = mcl_idx;
603 #if BTA_HL_DEBUG == TRUE
606 APPL_TRACE_DEBUG("bta_hl_find_cch_cb_indexes event=%s found=%d app_idx=%d mcl_idx=%d",
607 bta_hl_evt_code(p_msg->hdr.event), found, app_idx, mcl_idx);
614 /*******************************************************************************
616 ** Function bta_hl_find_dch_cb_indexes
618 ** Description This function finds the indexes needed for the DCH state machine
620 ** Returns BOOLEAN - TRUE found
623 *******************************************************************************/
624 BOOLEAN bta_hl_find_dch_cb_indexes(tBTA_HL_DATA *p_msg,
629 BOOLEAN found = FALSE;
630 tBTA_HL_MCL_CB *p_mcb;
631 UINT8 app_idx = 0, mcl_idx = 0, mdl_idx = 0;
633 switch (p_msg->hdr.event)
635 case BTA_HL_MCA_CREATE_CFM_EVT:
636 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
637 bta_hl_find_mdl_idx( app_idx, mcl_idx, p_msg->mca_evt.mca_data.create_cfm.mdl_id, &mdl_idx))
643 case BTA_HL_MCA_CREATE_IND_EVT:
644 case BTA_HL_MCA_RECONNECT_IND_EVT:
645 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
646 bta_hl_find_avail_mdl_idx( app_idx, mcl_idx, &mdl_idx))
652 case BTA_HL_MCA_OPEN_CFM_EVT:
653 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
654 bta_hl_find_mdl_idx( app_idx, mcl_idx, p_msg->mca_evt.mca_data.open_cfm.mdl_id, &mdl_idx))
660 case BTA_HL_MCA_OPEN_IND_EVT:
661 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
662 bta_hl_find_mdl_idx( app_idx, mcl_idx, p_msg->mca_evt.mca_data.open_ind.mdl_id, &mdl_idx))
668 case BTA_HL_MCA_CLOSE_CFM_EVT:
670 if (bta_hl_find_mdl_idx_using_handle((tBTA_HL_MDL_HANDLE)p_msg->mca_evt.mca_data.close_cfm.mdl,
671 &app_idx, &mcl_idx, &mdl_idx))
676 case BTA_HL_MCA_CLOSE_IND_EVT:
678 if (bta_hl_find_mdl_idx_using_handle((tBTA_HL_MDL_HANDLE)p_msg->mca_evt.mca_data.close_ind.mdl,
679 &app_idx, &mcl_idx, &mdl_idx))
684 case BTA_HL_API_SEND_DATA_EVT:
686 if (bta_hl_find_mdl_idx_using_handle(p_msg->api_send_data.mdl_handle,
687 &app_idx, &mcl_idx, &mdl_idx ))
694 case BTA_HL_MCA_CONG_CHG_EVT:
696 if (bta_hl_find_mdl_idx_using_handle((tBTA_HL_MDL_HANDLE)p_msg->mca_evt.mca_data.cong_chg.mdl,
697 &app_idx, &mcl_idx, &mdl_idx ))
704 case BTA_HL_MCA_RCV_DATA_EVT:
705 app_idx = p_msg->mca_rcv_data_evt.app_idx;
706 mcl_idx = p_msg->mca_rcv_data_evt.mcl_idx;
707 mdl_idx = p_msg->mca_rcv_data_evt.mdl_idx;
710 case BTA_HL_DCH_RECONNECT_EVT:
711 case BTA_HL_DCH_OPEN_EVT:
712 case BTA_HL_DCH_ECHO_TEST_EVT:
713 case BTA_HL_DCH_SDP_FAIL_EVT:
714 app_idx = p_msg->dch_sdp.app_idx;
715 mcl_idx = p_msg->dch_sdp.mcl_idx;
716 mdl_idx = p_msg->dch_sdp.mdl_idx;
719 case BTA_HL_MCA_RECONNECT_CFM_EVT:
720 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
721 bta_hl_find_mdl_idx( app_idx, mcl_idx, p_msg->mca_evt.mca_data.reconnect_cfm.mdl_id, &mdl_idx))
728 case BTA_HL_API_DCH_CREATE_RSP_EVT:
729 if (bta_hl_find_mcl_idx_using_handle(p_msg->api_dch_create_rsp.mcl_handle, &app_idx, &mcl_idx)&&
730 bta_hl_find_mdl_idx( app_idx, mcl_idx,p_msg->api_dch_create_rsp.mdl_id, &mdl_idx))
735 case BTA_HL_MCA_ABORT_IND_EVT:
736 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
737 bta_hl_find_mdl_idx( app_idx, mcl_idx,p_msg->mca_evt.mca_data.abort_ind.mdl_id, &mdl_idx))
742 case BTA_HL_MCA_ABORT_CFM_EVT:
743 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
744 bta_hl_find_mdl_idx( app_idx, mcl_idx, p_msg->mca_evt.mca_data.abort_cfm.mdl_id, &mdl_idx))
749 case BTA_HL_CI_GET_TX_DATA_EVT:
750 case BTA_HL_CI_PUT_RX_DATA_EVT:
751 if (bta_hl_find_mdl_idx_using_handle(p_msg->ci_get_put_data.mdl_handle, &app_idx, &mcl_idx, &mdl_idx))
756 case BTA_HL_CI_GET_ECHO_DATA_EVT:
757 case BTA_HL_CI_PUT_ECHO_DATA_EVT:
758 if (bta_hl_find_mcl_idx_using_handle(p_msg->ci_get_put_echo_data.mcl_handle, &app_idx, &mcl_idx))
760 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
761 mdl_idx = p_mcb->echo_mdl_idx;
773 *p_app_idx = app_idx;
774 *p_mcl_idx = mcl_idx;
775 *p_mdl_idx = mdl_idx;
777 #if BTA_HL_DEBUG == TRUE
780 APPL_TRACE_DEBUG("bta_hl_find_dch_cb_indexes event=%s found=%d app_idx=%d mcl_idx=%d mdl_idx=%d",
781 bta_hl_evt_code(p_msg->hdr.event), found, *p_app_idx, *p_mcl_idx, *p_mdl_idx );
788 /*******************************************************************************
790 ** Function bta_hl_allocate_mdl_id
792 ** Description This function allocates a MDL ID
794 ** Returns UINT16 - MDL ID
796 *******************************************************************************/
797 UINT16 bta_hl_allocate_mdl_id(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx )
800 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
801 BOOLEAN duplicate_id;
802 UINT8 i, mdl_cfg_idx;
806 duplicate_id = FALSE;
807 mdl_id = ((mdl_id+1) & 0xFEFF);
808 /* check mdl_ids that are used for the current conenctions */
809 for (i=0; i< BTA_HL_NUM_MDLS_PER_MCL; i++)
811 if (p_mcb->mdl[i].in_use &&
813 (p_mcb->mdl[i].mdl_id == mdl_id) )
822 /* start from the beginning to get another MDL value*/
827 /* check mdl_ids that are stored in the persistent memory */
828 if (bta_hl_find_mdl_cfg_idx(app_idx,mcl_idx, mdl_id, &mdl_cfg_idx))
834 /* found a new MDL value */
841 #if BTA_HL_DEBUG == TRUE
842 APPL_TRACE_DEBUG("bta_hl_allocate_mdl OK mdl_id=%d", mdl_id);
846 /*******************************************************************************
848 ** Function bta_hl_find_mdl_idx
850 ** Description This function finds the MDL index based on mdl_id
852 ** Returns BOOLEAN TRUE-found
854 *******************************************************************************/
855 BOOLEAN bta_hl_find_mdl_idx(UINT8 app_idx, UINT8 mcl_idx, UINT16 mdl_id,
858 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
862 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
864 if (p_mcb->mdl[i].in_use &&
866 (p_mcb->mdl[i].mdl_id== mdl_id))
874 #if BTA_HL_DEBUG == TRUE
877 APPL_TRACE_DEBUG("bta_hl_find_mdl_idx found=%d mdl_id=%d mdl_idx=%d ",
885 /*******************************************************************************
887 ** Function bta_hl_find_an_active_mdl_idx
889 ** Description This function finds an active MDL
891 ** Returns BOOLEAN TRUE-found
893 *******************************************************************************/
894 BOOLEAN bta_hl_find_an_active_mdl_idx(UINT8 app_idx, UINT8 mcl_idx,
897 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
901 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
903 if (p_mcb->mdl[i].in_use &&
904 (p_mcb->mdl[i].dch_state == BTA_HL_DCH_OPEN_ST))
912 #if BTA_HL_DEBUG == TRUE
915 APPL_TRACE_DEBUG("bta_hl_find_an_opened_mdl_idx found=%d app_idx=%d mcl_idx=%d mdl_idx=%d",
916 found, app_idx, mcl_idx, i);
923 /*******************************************************************************
925 ** Function bta_hl_find_dch_setup_mdl_idx
927 ** Description This function finds a MDL which in the DCH setup state
929 ** Returns BOOLEAN TRUE-found
931 *******************************************************************************/
932 BOOLEAN bta_hl_find_dch_setup_mdl_idx(UINT8 app_idx, UINT8 mcl_idx,
935 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
939 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
941 if (p_mcb->mdl[i].in_use &&
942 (p_mcb->mdl[i].dch_state == BTA_HL_DCH_OPENING_ST))
950 #if BTA_HL_DEBUG == TRUE
953 APPL_TRACE_DEBUG("bta_hl_find_dch_setup_mdl_idx found=%d app_idx=%d mcl_idx=%d mdl_idx=%d",
954 found, app_idx, mcl_idx, i);
961 /*******************************************************************************
963 ** Function bta_hl_find_an_in_use_mcl_idx
965 ** Description This function finds an in-use MCL control block index
967 ** Returns BOOLEAN TRUE-found
969 *******************************************************************************/
970 BOOLEAN bta_hl_find_an_in_use_mcl_idx(UINT8 app_idx,
973 tBTA_HL_MCL_CB *p_mcb;
977 for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
979 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, i);
981 (p_mcb->cch_state != BTA_HL_CCH_IDLE_ST))
989 #if BTA_HL_DEBUG == TRUE
992 APPL_TRACE_DEBUG("bta_hl_find_an_in_use_mcl_idx found=%d app_idx=%d mcl_idx=%d ",
1001 /*******************************************************************************
1003 ** Function bta_hl_find_an_in_use_app_idx
1005 ** Description This function finds an in-use application control block index
1007 ** Returns BOOLEAN TRUE-found
1009 *******************************************************************************/
1010 BOOLEAN bta_hl_find_an_in_use_app_idx(UINT8 *p_app_idx)
1012 tBTA_HL_APP_CB *p_acb ;
1013 BOOLEAN found=FALSE;
1016 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1018 p_acb = BTA_HL_GET_APP_CB_PTR(i);
1027 #if BTA_HL_DEBUG == TRUE
1030 APPL_TRACE_DEBUG("bta_hl_find_an_in_use_app_idx found=%d app_idx=%d ",
1037 /*******************************************************************************
1039 ** Function bta_hl_find_app_idx
1041 ** Description This function finds the application control block index based on
1042 ** the application ID
1044 ** Returns BOOLEAN TRUE-found
1046 *******************************************************************************/
1047 BOOLEAN bta_hl_find_app_idx(UINT8 app_id, UINT8 *p_app_idx)
1049 BOOLEAN found=FALSE;
1052 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1054 if (bta_hl_cb.acb[i].in_use &&
1055 (bta_hl_cb.acb[i].app_id == app_id))
1063 #if BTA_HL_DEBUG == TRUE
1064 APPL_TRACE_DEBUG("bta_hl_find_app_idx found=%d app_id=%d idx=%d ",
1072 /*******************************************************************************
1074 ** Function bta_hl_find_app_idx_using_handle
1076 ** Description This function finds the application control block index based on
1077 ** the application handle
1079 ** Returns BOOLEAN TRUE-found
1081 *******************************************************************************/
1082 BOOLEAN bta_hl_find_app_idx_using_handle(tBTA_HL_APP_HANDLE app_handle,
1085 BOOLEAN found=FALSE;
1088 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1090 if (bta_hl_cb.acb[i].in_use &&
1091 (bta_hl_cb.acb[i].app_handle == app_handle))
1099 #if BTA_HL_DEBUG == TRUE
1102 APPL_TRACE_DEBUG("bta_hl_find_app_idx_using_mca_handle status=%d handle=%d app_idx=%d ",
1103 found, app_handle , i);
1111 /*******************************************************************************
1113 ** Function bta_hl_find_mcl_idx_using_handle
1115 ** Description This function finds the MCL control block index based on
1118 ** Returns BOOLEAN TRUE-found
1120 *******************************************************************************/
1121 BOOLEAN bta_hl_find_mcl_idx_using_handle( tBTA_HL_MCL_HANDLE mcl_handle,
1122 UINT8 *p_app_idx, UINT8 *p_mcl_idx)
1124 tBTA_HL_APP_CB *p_acb;
1125 BOOLEAN found=FALSE;
1128 for (i=0; i<BTA_HL_NUM_APPS; i++)
1130 p_acb = BTA_HL_GET_APP_CB_PTR(i);
1133 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
1135 if ( p_acb->mcb[j].mcl_handle == mcl_handle )
1146 #if BTA_HL_DEBUG == TRUE
1149 APPL_TRACE_DEBUG("bta_hl_find_mcl_idx_using_handle found=%d app_idx=%d mcl_idx=%d",
1156 /*******************************************************************************
1158 ** Function bta_hl_find_mcl_idx
1160 ** Description This function finds the MCL control block index based on
1161 ** the peer BD address
1163 ** Returns BOOLEAN TRUE-found
1165 *******************************************************************************/
1166 BOOLEAN bta_hl_find_mcl_idx(UINT8 app_idx, BD_ADDR p_bd_addr, UINT8 *p_mcl_idx)
1168 BOOLEAN found=FALSE;
1171 for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
1173 if (bta_hl_cb.acb[app_idx].mcb[i].in_use &&
1174 (!memcmp (bta_hl_cb.acb[app_idx].mcb[i].bd_addr, p_bd_addr, BD_ADDR_LEN)))
1182 #if BTA_HL_DEBUG == TRUE
1185 APPL_TRACE_DEBUG("bta_hl_find_mcl_idx found=%d idx=%d",
1194 /*******************************************************************************
1196 ** Function bta_hl_find_mdl_idx_using_handle
1198 ** Description This function finds the MDL control block index based on
1201 ** Returns BOOLEAN TRUE-found
1203 *******************************************************************************/
1204 BOOLEAN bta_hl_find_mdl_idx_using_handle(tBTA_HL_MDL_HANDLE mdl_handle,
1205 UINT8 *p_app_idx,UINT8 *p_mcl_idx,
1208 tBTA_HL_APP_CB *p_acb;
1209 tBTA_HL_MCL_CB *p_mcb;
1210 tBTA_HL_MDL_CB *p_dcb;
1211 BOOLEAN found=FALSE;
1214 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1216 p_acb = BTA_HL_GET_APP_CB_PTR(i);
1219 for (j=0; j< BTA_HL_NUM_MCLS; j++)
1221 p_mcb = BTA_HL_GET_MCL_CB_PTR(i,j);
1224 for (k=0; k< BTA_HL_NUM_MDLS_PER_MCL; k++)
1226 p_dcb = BTA_HL_GET_MDL_CB_PTR(i,j,k);
1229 if (p_dcb->mdl_handle == mdl_handle)
1245 #if BTA_HL_DEBUG == TRUE
1248 APPL_TRACE_DEBUG("bta_hl_find_mdl_idx_using_handle found=%d mdl_handle=%d ",
1254 /*******************************************************************************
1256 ** Function bta_hl_is_the_first_reliable_existed
1258 ** Description This function checks whether the first reliable DCH channel
1259 ** has been setup on the MCL or not
1261 ** Returns BOOLEAN - TRUE exist
1262 ** FALSE does not exist
1264 *******************************************************************************/
1265 BOOLEAN bta_hl_is_the_first_reliable_existed(UINT8 app_idx, UINT8 mcl_idx )
1267 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1268 BOOLEAN is_existed =FALSE;
1271 for (i=0; i< BTA_HL_NUM_MDLS_PER_MCL; i++)
1273 if (p_mcb->mdl[i].in_use && p_mcb->mdl[i].is_the_first_reliable)
1280 #if BTA_HL_DEBUG == TRUE
1281 APPL_TRACE_DEBUG("bta_hl_is_the_first_reliable_existed is_existed=%d ",is_existed );
1286 /*******************************************************************************
1288 ** Function bta_hl_find_non_active_mdl_cfg
1290 ** Description This function finds a valid MDL configiration index and this
1291 ** MDL ID is not active
1293 ** Returns BOOLEAN - TRUE found
1296 *******************************************************************************/
1297 BOOLEAN bta_hl_find_non_active_mdl_cfg(UINT8 app_idx, UINT8 start_mdl_cfg_idx,
1298 UINT8 *p_mdl_cfg_idx)
1301 tBTA_HL_MCL_CB *p_mcb;
1302 tBTA_HL_MDL_CB *p_dcb;
1303 tBTA_HL_MDL_CFG *p_mdl;
1305 BOOLEAN found = FALSE;
1308 for (i = start_mdl_cfg_idx; i< BTA_HL_NUM_MDL_CFGS; i++)
1311 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1312 for (j=0; j< BTA_HL_NUM_MCLS; j++)
1314 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, j);
1315 if (p_mcb->in_use &&
1316 !memcmp(p_mdl->peer_bd_addr,p_mcb->bd_addr,BD_ADDR_LEN))
1319 for (k=0; k<BTA_HL_NUM_MDLS_PER_MCL; k++)
1321 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, j, k);
1323 if (p_dcb->in_use && p_mdl->mdl_id == p_dcb->mdl_id)
1348 /*******************************************************************************
1350 ** Function bta_hl_find_mdl_cfg_idx
1352 ** Description This function finds an available MDL configuration index
1354 ** Returns BOOLEAN - TRUE found
1357 *******************************************************************************/
1358 BOOLEAN bta_hl_find_avail_mdl_cfg_idx(UINT8 app_idx, UINT8 mcl_idx,
1359 UINT8 *p_mdl_cfg_idx)
1361 tBTA_HL_MDL_CFG *p_mdl, *p_mdl1, *p_mdl2;
1363 BOOLEAN found=FALSE;
1364 UINT8 first_mdl_cfg_idx, second_mdl_cfg_idx, older_mdl_cfg_idx;
1368 for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1370 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1371 if (!p_mdl->active )
1373 /* found an unused space to store mdl cfg*/
1382 /* all available mdl cfg spaces are in use so we need to find the mdl cfg which is
1383 not currently in use and has the the oldest time stamp to remove*/
1386 if (bta_hl_find_non_active_mdl_cfg(app_idx,0, &first_mdl_cfg_idx))
1388 if (bta_hl_find_non_active_mdl_cfg(app_idx,(UINT8) (first_mdl_cfg_idx+1), &second_mdl_cfg_idx))
1393 p_mdl1 = BTA_HL_GET_MDL_CFG_PTR(app_idx, first_mdl_cfg_idx);
1394 p_mdl2 = BTA_HL_GET_MDL_CFG_PTR(app_idx, second_mdl_cfg_idx);
1396 if (p_mdl1->time < p_mdl2->time)
1398 older_mdl_cfg_idx = first_mdl_cfg_idx;
1402 older_mdl_cfg_idx = second_mdl_cfg_idx;
1405 if (bta_hl_find_non_active_mdl_cfg(app_idx,(UINT8) (second_mdl_cfg_idx+1), &second_mdl_cfg_idx))
1407 first_mdl_cfg_idx = older_mdl_cfg_idx;
1415 *p_mdl_cfg_idx = older_mdl_cfg_idx;
1420 *p_mdl_cfg_idx = first_mdl_cfg_idx;
1430 #if BTA_HL_DEBUG == TRUE
1433 APPL_TRACE_DEBUG("bta_hl_find_avail_mdl_cfg_idx found=%d mdl_cfg_idx=%d ",found, *p_mdl_cfg_idx );
1442 /*******************************************************************************
1444 ** Function bta_hl_find_mdl_cfg_idx
1446 ** Description This function finds the MDL configuration index based on
1449 ** Returns BOOLEAN - TRUE found
1452 *******************************************************************************/
1453 BOOLEAN bta_hl_find_mdl_cfg_idx(UINT8 app_idx, UINT8 mcl_idx,
1454 tBTA_HL_MDL_ID mdl_id, UINT8 *p_mdl_cfg_idx)
1456 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1457 tBTA_HL_MDL_CFG *p_mdl;
1459 BOOLEAN found=FALSE;
1462 for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1464 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1466 APPL_TRACE_DEBUG("bta_hl_find_mdl_cfg_idx: mdl_id =%d, p_mdl->mdl_id=%d",mdl_id,
1468 if (p_mdl->active &&
1469 (!memcmp (p_mcb->bd_addr, p_mdl->peer_bd_addr, BD_ADDR_LEN))&&
1470 (p_mdl->mdl_id == mdl_id))
1478 #if BTA_HL_DEBUG == TRUE
1481 APPL_TRACE_DEBUG("bta_hl_find_mdl_cfg_idx found=%d mdl_cfg_idx=%d ",found, i );
1491 /*******************************************************************************
1493 ** Function bta_hl_get_cur_time
1495 ** Description This function get the cuurent time value
1497 ** Returns BOOLEAN - TRUE found
1500 *******************************************************************************/
1501 BOOLEAN bta_hl_get_cur_time(UINT8 app_idx, UINT8 *p_cur_time)
1503 tBTA_HL_MDL_CFG *p_mdl;
1504 UINT8 i, j, time_latest, time;
1505 BOOLEAN found=FALSE, result=TRUE;
1507 for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1509 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1513 time_latest = p_mdl->time;
1514 for (j=(i+1); j< BTA_HL_NUM_MDL_CFGS; j++ )
1516 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, j);
1520 if (time > time_latest)
1533 if (time_latest < BTA_HL_MAX_TIME)
1535 *p_cur_time = time_latest+1;
1539 /* need to wrap around */
1545 *p_cur_time = BTA_HL_MIN_TIME;
1548 #if BTA_HL_DEBUG == TRUE
1551 APPL_TRACE_DEBUG("bta_hl_get_cur_time result=%s cur_time=%d",
1552 (result?"OK":"FAIL"), *p_cur_time);
1559 /*******************************************************************************
1561 ** Function bta_hl_sort_cfg_time_idx
1563 ** Description This function sort the mdl configuration idx stored in array a
1564 ** based on decending time value
1566 ** Returns BOOLEAN - TRUE found
1569 *******************************************************************************/
1570 void bta_hl_sort_cfg_time_idx(UINT8 app_idx, UINT8 *a, UINT8 n)
1572 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1573 UINT8 temp_time, temp_idx;
1575 for (i = 1; i < n; ++i)
1578 temp_time = p_acb->mdl_cfg[temp_idx].time;
1580 while ((j >= 0) && (temp_time < p_acb->mdl_cfg[a[j]].time))
1585 a[j + 1] = temp_idx;
1589 /*******************************************************************************
1591 ** Function bta_hl_compact_mdl_cfg_time
1593 ** Description This function finds the MDL configuration index based on
1596 ** Returns BOOLEAN - TRUE found
1599 *******************************************************************************/
1600 void bta_hl_compact_mdl_cfg_time(UINT8 app_idx, UINT8 mdep_id)
1602 tBTA_HL_MDL_CFG *p_mdl;
1603 UINT8 i, time_min, cnt=0;
1604 UINT8 s_arr[BTA_HL_NUM_MDL_CFGS];
1607 for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1609 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1619 #if BTA_HL_DEBUG == TRUE
1620 APPL_TRACE_DEBUG("bta_hl_compact_mdl_cfg_time cnt=%d ",cnt );
1626 bta_hl_sort_cfg_time_idx(app_idx, s_arr, cnt);
1627 time_min = BTA_HL_MIN_TIME;
1628 for (i=0;i<cnt; i++)
1630 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, s_arr[i]);
1631 p_mdl->time = time_min + i;
1632 bta_hl_co_save_mdl(mdep_id, s_arr[i], p_mdl);
1641 /*******************************************************************************
1643 ** Function bta_hl_is_mdl_exsit_in_mcl
1645 ** Description This function checks whether the MDL ID
1646 ** has already existed in teh MCL or not
1648 ** Returns BOOLEAN - TRUE exist
1649 ** FALSE does not exist
1651 *******************************************************************************/
1652 BOOLEAN bta_hl_is_mdl_exsit_in_mcl(UINT8 app_idx, BD_ADDR bd_addr,
1653 tBTA_HL_MDL_ID mdl_id)
1655 tBTA_HL_MDL_CFG *p_mdl;
1656 BOOLEAN found = FALSE;
1659 for (i = 0; i< BTA_HL_NUM_MDL_CFGS; i++)
1661 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1662 if (p_mdl->active &&
1663 !memcmp(p_mdl->peer_bd_addr, bd_addr,BD_ADDR_LEN))
1665 if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS)
1667 if (p_mdl->mdl_id == mdl_id)
1684 /*******************************************************************************
1686 ** Function bta_hl_delete_mdl_cfg
1688 ** Description This function delete the specified MDL ID
1690 ** Returns BOOLEAN - TRUE Success
1693 *******************************************************************************/
1694 BOOLEAN bta_hl_delete_mdl_cfg(UINT8 app_idx, BD_ADDR bd_addr,
1695 tBTA_HL_MDL_ID mdl_id)
1697 tBTA_HL_MDL_CFG *p_mdl;
1698 BOOLEAN success = FALSE;
1701 for (i = 0; i< BTA_HL_NUM_MDL_CFGS; i++)
1703 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1704 if (p_mdl->active &&
1705 !memcmp(p_mdl->peer_bd_addr, bd_addr,BD_ADDR_LEN))
1707 if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS)
1709 if (p_mdl->mdl_id == mdl_id)
1711 bta_hl_co_delete_mdl(p_mdl->local_mdep_id, i);
1712 memset(p_mdl, 0, sizeof(tBTA_HL_MDL_CFG));
1719 bta_hl_co_delete_mdl(p_mdl->local_mdep_id, i);
1720 memset(p_mdl, 0, sizeof(tBTA_HL_MDL_CFG));
1730 /*******************************************************************************
1732 ** Function bta_hl_is_mdl_value_valid
1735 ** Description This function checks the specified MDL ID is in valid range or not
1737 ** Returns BOOLEAN - TRUE Success
1740 ** note: mdl_id range 0x0000 reserved,
1741 ** 0x0001-oxFEFF dynamic range,
1742 ** 0xFF00-0xFFFE reserved,
1743 ** 0xFFFF indicates all MDLs (for delete operation only)
1745 *******************************************************************************/
1746 BOOLEAN bta_hl_is_mdl_value_valid(tBTA_HL_MDL_ID mdl_id)
1748 BOOLEAN status = TRUE;
1750 if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS)
1754 if (mdl_id > BTA_HL_MAX_MDL_VAL )
1768 /*******************************************************************************
1770 ** Function bta_hl_find_mdep_cfg_idx
1772 ** Description This function finds the MDEP configuration index based
1773 ** on the local MDEP ID
1775 ** Returns BOOLEAN - TRUE found
1778 *******************************************************************************/
1779 BOOLEAN bta_hl_find_mdep_cfg_idx(UINT8 app_idx, tBTA_HL_MDEP_ID local_mdep_id,
1780 UINT8 *p_mdep_cfg_idx)
1782 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1783 tBTA_HL_SUP_FEATURE *p_sup_feature= &p_acb->sup_feature;
1784 BOOLEAN found =FALSE;
1787 for (i=0; i< p_sup_feature->num_of_mdeps; i++)
1789 if ( p_sup_feature->mdep[i].mdep_id == local_mdep_id)
1792 *p_mdep_cfg_idx = i;
1797 #if BTA_HL_DEBUG == TRUE
1800 APPL_TRACE_DEBUG("bta_hl_find_mdep_cfg_idx found=%d mdep_idx=%d local_mdep_id=%d ",
1801 found,i, local_mdep_id );
1808 /*******************************************************************************
1810 ** Function bta_hl_find_rxtx_apdu_size
1812 ** Description This function finds the maximum APDU rx and tx sizes based on
1813 ** the MDEP configuration data
1817 *******************************************************************************/
1818 void bta_hl_find_rxtx_apdu_size(UINT8 app_idx, UINT8 mdep_cfg_idx,
1819 UINT16 *p_rx_apu_size,
1820 UINT16 *p_tx_apu_size)
1822 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1823 tBTA_HL_MDEP_CFG *p_mdep_cfg;
1825 UINT16 max_rx_apdu_size=0, max_tx_apdu_size=0;
1827 p_mdep_cfg = &p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg;
1830 for (i=0; i< p_mdep_cfg->num_of_mdep_data_types ; i++)
1833 if (max_rx_apdu_size < p_mdep_cfg->data_cfg[i].max_rx_apdu_size)
1835 max_rx_apdu_size = p_mdep_cfg->data_cfg[i].max_rx_apdu_size;
1838 if (max_tx_apdu_size < p_mdep_cfg->data_cfg[i].max_tx_apdu_size)
1840 max_tx_apdu_size = p_mdep_cfg->data_cfg[i].max_tx_apdu_size;
1845 *p_rx_apu_size = max_rx_apdu_size;
1846 *p_tx_apu_size = max_tx_apdu_size;
1848 #if BTA_HL_DEBUG == TRUE
1849 APPL_TRACE_DEBUG("bta_hl_find_rxtx_apdu_size max_rx_apdu_size=%d max_tx_apdu_size=%d ",
1850 max_rx_apdu_size, max_tx_apdu_size );
1856 /*******************************************************************************
1858 ** Function bta_hl_validate_peer_cfg
1860 ** Description This function validates the peer DCH configuration
1862 ** Returns BOOLEAN - TRUE validation is successful
1863 ** FALSE validation failed
1865 *******************************************************************************/
1866 BOOLEAN bta_hl_validate_peer_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
1867 tBTA_HL_MDEP_ID peer_mdep_id,
1868 tBTA_HL_MDEP_ROLE peer_mdep_role,
1871 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1872 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1873 tBTA_HL_SDP_REC *p_rec;
1874 BOOLEAN peer_found =FALSE;
1877 APPL_TRACE_DEBUG("bta_hl_validate_peer_cfg sdp_idx=%d app_idx %d", sdp_idx, app_idx);
1880 if (p_dcb->local_mdep_id == BTA_HL_ECHO_TEST_MDEP_ID)
1885 p_rec = &p_mcb->sdp.sdp_rec[sdp_idx];
1886 for (i=0; i< p_rec->num_mdeps; i++)
1888 APPL_TRACE_DEBUG("mdep_id %d peer_mdep_id %d",p_rec->mdep_cfg[i].mdep_id , peer_mdep_id);
1889 APPL_TRACE_DEBUG("mdep_role %d peer_mdep_role %d",p_rec->mdep_cfg[i].mdep_role,
1891 if ( (p_rec->mdep_cfg[i].mdep_id == peer_mdep_id) &&
1892 (p_rec->mdep_cfg[i].mdep_role == peer_mdep_role))
1900 #if BTA_HL_DEBUG == TRUE
1903 APPL_TRACE_DEBUG("bta_hl_validate_peer_cfg failed num_mdeps=%d",p_rec->num_mdeps);
1909 /*******************************************************************************
1911 ** Function bta_hl_chk_local_cfg
1913 ** Description This function check whether the local DCH configuration is OK or not
1915 ** Returns tBTA_HL_STATUS - OK - local DCH configuration is OK
1916 ** NO_FIRST_RELIABLE - the streaming DCH configuration
1917 ** is not OK and it needs to use
1918 ** reliable DCH configuration
1920 *******************************************************************************/
1921 tBTA_HL_STATUS bta_hl_chk_local_cfg(UINT8 app_idx, UINT8 mcl_idx,
1923 tBTA_HL_DCH_CFG local_cfg)
1925 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1926 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
1928 if ( mdep_cfg_idx &&
1929 (p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SOURCE) &&
1930 (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx)) &&
1931 (local_cfg != BTA_HL_DCH_CFG_RELIABLE))
1933 status = BTA_HL_STATUS_NO_FIRST_RELIABLE;
1934 APPL_TRACE_ERROR("BTA_HL_STATUS_INVALID_DCH_CFG");
1941 /*******************************************************************************
1943 ** Function bta_hl_validate_reconnect_params
1945 ** Description This function validates the reconnect parameters
1947 ** Returns BOOLEAN - TRUE validation is successful
1948 ** FALSE validation failed
1949 *******************************************************************************/
1950 BOOLEAN bta_hl_validate_reconnect_params(UINT8 app_idx, UINT8 mcl_idx,
1951 tBTA_HL_API_DCH_RECONNECT *p_reconnect,
1952 UINT8 *p_mdep_cfg_idx, UINT8 *p_mdl_cfg_idx)
1954 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1955 tBTA_HL_SUP_FEATURE *p_sup_feature = &p_acb->sup_feature;
1958 BOOLEAN local_mdep_id_found =FALSE;
1959 BOOLEAN mdl_cfg_found =FALSE;
1960 BOOLEAN status=FALSE;
1961 UINT8 i, in_use_mdl_idx = 0;
1963 #if BTA_HL_DEBUG == TRUE
1964 APPL_TRACE_DEBUG("bta_hl_validate_reconnect_params mdl_id=%d app_idx=%d", p_reconnect->mdl_id, app_idx);
1966 if (bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, p_reconnect->mdl_id, &mdl_cfg_idx))
1968 mdl_cfg_found = TRUE;
1971 #if BTA_HL_DEBUG == TRUE
1974 APPL_TRACE_DEBUG("mdl_cfg_found not found");
1981 num_mdeps = p_sup_feature->num_of_mdeps;
1982 for (i=0; i< num_mdeps ; i++)
1984 if ( p_sup_feature->mdep[i].mdep_id == p_acb->mdl_cfg[mdl_cfg_idx].local_mdep_id)
1986 local_mdep_id_found = TRUE;
1988 *p_mdl_cfg_idx = mdl_cfg_idx;
1994 #if BTA_HL_DEBUG == TRUE
1995 if (!local_mdep_id_found)
1997 APPL_TRACE_DEBUG("local_mdep_id not found");
2002 if (local_mdep_id_found)
2004 if (!bta_hl_find_mdl_idx(app_idx,mcl_idx, p_reconnect->mdl_id, &in_use_mdl_idx))
2010 APPL_TRACE_ERROR("mdl_id=%d is curreltly in use",p_reconnect->mdl_id);
2014 #if BTA_HL_DEBUG == TRUE
2017 APPL_TRACE_DEBUG("Reconnect validation failed local_mdep_id found=%d mdl_cfg_idx found=%d in_use_mdl_idx=%d ",
2018 local_mdep_id_found, mdl_cfg_found, in_use_mdl_idx);
2024 /*******************************************************************************
2026 ** Function bta_hl_find_avail_mcl_idx
2028 ** Returns BOOLEAN - TRUE found
2031 *******************************************************************************/
2032 BOOLEAN bta_hl_find_avail_mcl_idx(UINT8 app_idx, UINT8 *p_mcl_idx)
2034 BOOLEAN found=FALSE;
2037 for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
2039 if (!bta_hl_cb.acb[app_idx].mcb[i].in_use)
2047 #if BTA_HL_DEBUG == TRUE
2050 APPL_TRACE_DEBUG("bta_hl_find_avail_mcl_idx found=%d idx=%d",
2059 /*******************************************************************************
2061 ** Function bta_hl_find_avail_mdl_idx
2063 ** Description This function finds an available MDL control block index
2065 ** Returns BOOLEAN - TRUE found
2068 *******************************************************************************/
2069 BOOLEAN bta_hl_find_avail_mdl_idx(UINT8 app_idx, UINT8 mcl_idx,
2072 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2073 BOOLEAN found=FALSE;
2076 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
2078 if (!p_mcb->mdl[i].in_use)
2080 memset((void *)&p_mcb->mdl[i],0, sizeof(tBTA_HL_MDL_CB));
2087 #if BTA_HL_DEBUG == TRUE
2090 APPL_TRACE_DEBUG("bta_hl_find_avail_mdl_idx found=%d idx=%d",
2097 /*******************************************************************************
2099 ** Function bta_hl_is_a_duplicate_id
2101 ** Description This function finds the application has been used or not
2103 ** Returns BOOLEAN - TRUE the app_id is a duplicate ID
2104 ** FALSE not a duplicate ID
2105 *******************************************************************************/
2106 BOOLEAN bta_hl_is_a_duplicate_id(UINT8 app_id)
2108 BOOLEAN is_duplicate=FALSE;
2111 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
2113 if (bta_hl_cb.acb[i].in_use &&
2114 (bta_hl_cb.acb[i].app_id == app_id))
2116 is_duplicate = TRUE;
2122 #if BTA_HL_DEBUG == TRUE
2126 APPL_TRACE_DEBUG("bta_hl_is_a_duplicate_id app_id=%d is_duplicate=%d",
2127 app_id, is_duplicate);
2131 return is_duplicate;
2135 /*******************************************************************************
2137 ** Function bta_hl_find_avail_app_idx
2139 ** Description This function finds an available application control block index
2141 ** Returns BOOLEAN - TRUE found
2144 *******************************************************************************/
2145 BOOLEAN bta_hl_find_avail_app_idx(UINT8 *p_idx)
2147 BOOLEAN found=FALSE;
2150 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
2152 if (!bta_hl_cb.acb[i].in_use)
2160 #if BTA_HL_DEBUG == TRUE
2163 APPL_TRACE_DEBUG("bta_hl_find_avail_app_idx found=%d app_idx=%d",
2170 /*******************************************************************************
2172 ** Function bta_hl_app_update
2174 ** Description This function registers an HDP application MCAP and DP
2176 ** Returns tBTA_HL_STATUS -registration status
2178 *******************************************************************************/
2179 tBTA_HL_STATUS bta_hl_app_update(UINT8 app_id, BOOLEAN is_register)
2181 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
2182 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(0);
2184 UINT8 i, mdep_idx, num_of_mdeps;
2185 UINT8 mdep_counter = 0;
2188 #if BTA_HL_DEBUG == TRUE
2189 APPL_TRACE_DEBUG("bta_hl_app_update app_id=%d", app_id);
2194 if ((status == BTA_HL_STATUS_OK) &&
2195 bta_hl_co_get_num_of_mdep(app_id, &num_of_mdeps))
2197 for (i=0; i < num_of_mdeps; i++)
2199 mca_cs.type = MCA_TDEP_DATA;
2200 mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
2201 mca_cs.p_data_cback = bta_hl_mcap_data_cback;
2202 /* Find the first available mdep index, and create a MDL Endpoint */
2203 // make a function later if needed
2204 for (mdep_idx = 1; mdep_idx < BTA_HL_NUM_MDEPS; mdep_idx++)
2206 if ( p_acb->sup_feature.mdep[mdep_idx].mdep_id == 0)
2208 break; /* We found an available index */
2215 /* If no available MDEPs, return error */
2216 if (mdep_idx == BTA_HL_NUM_MDEPS)
2218 APPL_TRACE_ERROR("bta_hl_app_update: Out of MDEP IDs");
2219 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2222 if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
2223 &(p_acb->sup_feature.mdep[mdep_idx].mdep_id), &mca_cs) == MCA_SUCCESS)
2225 if (bta_hl_co_get_mdep_config(app_id,
2228 p_acb->sup_feature.mdep[mdep_idx].mdep_id,
2229 &p_acb->sup_feature.mdep[mdep_idx].mdep_cfg))
2231 p_acb->sup_feature.mdep[mdep_idx].ori_app_id = app_id;
2232 APPL_TRACE_DEBUG("mdep idx %d id %d ori_app_id %d num data type %d",mdep_idx,
2233 p_acb->sup_feature.mdep[mdep_idx].mdep_id,
2234 p_acb->sup_feature.mdep[mdep_idx].ori_app_id,
2235 p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.num_of_mdep_data_types);
2236 if (p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.mdep_role ==
2237 BTA_HL_MDEP_ROLE_SOURCE)
2239 p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SOURCE;
2241 else if (p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.mdep_role ==
2242 BTA_HL_MDEP_ROLE_SINK)
2244 p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SINK;
2248 APPL_TRACE_ERROR("bta_hl_app_registration: Invalid Role %d",
2249 p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.mdep_role);
2250 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2256 APPL_TRACE_ERROR("bta_hl_app_registration: Cfg callout failed");
2257 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2263 APPL_TRACE_ERROR("bta_hl_app_registration: MCA_CreateDep failed");
2264 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2269 p_acb->sup_feature.num_of_mdeps += num_of_mdeps;
2270 APPL_TRACE_DEBUG("num_of_mdeps %d", p_acb->sup_feature.num_of_mdeps);
2272 if ((status == BTA_HL_STATUS_OK) &&
2273 (p_acb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SOURCE))
2275 p_acb->sup_feature.advertize_source_sdp =
2276 bta_hl_co_advrtise_source_sdp(app_id);
2279 if ((status == BTA_HL_STATUS_OK)&&
2280 (!bta_hl_co_get_echo_config(app_id, &p_acb->sup_feature.echo_cfg)))
2282 status = BTA_HL_STATUS_ECHO_CO_FAIL;
2285 if ((status == BTA_HL_STATUS_OK)&&
2286 (!bta_hl_co_load_mdl_config(app_id, BTA_HL_NUM_MDL_CFGS, &p_acb->mdl_cfg[0])))
2288 status = BTA_HL_STATUS_MDL_CFG_CO_FAIL;
2293 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2298 for (i=1; i<BTA_HL_NUM_MDEPS; i++)
2300 if (p_acb->sup_feature.mdep[i].ori_app_id == app_id)
2302 APPL_TRACE_DEBUG("Found index %", i);
2305 if (MCA_DeleteDep((tMCA_HANDLE)p_acb->app_handle,
2306 (p_acb->sup_feature.mdep[i].mdep_id)) != MCA_SUCCESS)
2308 APPL_TRACE_ERROR("Error deregistering");
2309 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2312 memset(&p_acb->sup_feature.mdep[i], 0, sizeof(tBTA_HL_MDEP));
2319 if (status == BTA_HL_STATUS_OK)
2321 /* Register/Update MDEP(s) in SDP Record */
2322 status = bta_hl_sdp_update(app_id);
2324 /* else do cleanup */
2331 /*******************************************************************************
2333 ** Function bta_hl_app_registration
2335 ** Description This function registers an HDP application MCAP and DP
2337 ** Returns tBTA_HL_STATUS -registration status
2339 *******************************************************************************/
2340 tBTA_HL_STATUS bta_hl_app_registration(UINT8 app_idx)
2342 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
2343 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2346 UINT8 i, num_of_mdeps;
2347 UINT8 mdep_counter = 0;
2349 #if BTA_HL_DEBUG == TRUE
2350 APPL_TRACE_DEBUG("bta_hl_app_registration app_idx=%d", app_idx);
2353 reg.ctrl_psm = p_acb->ctrl_psm;
2354 reg.data_psm = p_acb->data_psm;
2355 reg.sec_mask = p_acb->sec_mask;
2356 reg.rsp_tout = BTA_HL_MCAP_RSP_TOUT;
2358 if ( (p_acb->app_handle = (tBTA_HL_APP_HANDLE) MCA_Register(®, bta_hl_mcap_ctrl_cback))!=0)
2360 mca_cs.type = MCA_TDEP_ECHO;
2361 mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
2362 mca_cs.p_data_cback = bta_hl_mcap_data_cback;
2364 if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
2365 &(p_acb->sup_feature.mdep[0].mdep_id),
2366 &mca_cs) == MCA_SUCCESS)
2368 if (p_acb->sup_feature.mdep[0].mdep_id != BTA_HL_ECHO_TEST_MDEP_ID)
2370 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2371 APPL_TRACE_ERROR("BAD MDEP ID for echo test mdep_id=%d",
2372 p_acb->sup_feature.mdep[0].mdep_id );
2377 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2378 APPL_TRACE_ERROR("MCA_CreateDep for echo test(mdep_id=0) failed");
2382 if ((status == BTA_HL_STATUS_OK) &&
2383 bta_hl_co_get_num_of_mdep(p_acb->app_id, &num_of_mdeps))
2385 p_acb->sup_feature.num_of_mdeps = num_of_mdeps+1;
2387 for (i=1; i<p_acb->sup_feature.num_of_mdeps; i++)
2389 mca_cs.type = MCA_TDEP_DATA;
2390 mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
2391 mca_cs.p_data_cback = bta_hl_mcap_data_cback;
2393 if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
2394 &(p_acb->sup_feature.mdep[i].mdep_id), &mca_cs) == MCA_SUCCESS)
2396 if (bta_hl_co_get_mdep_config(p_acb->app_id,
2398 p_acb->sup_feature.mdep[i].mdep_id,
2399 &p_acb->sup_feature.mdep[i].mdep_cfg))
2401 if (p_acb->sup_feature.mdep[i].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
2403 p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SOURCE;
2405 else if (p_acb->sup_feature.mdep[i].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SINK)
2407 p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SINK;
2411 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2414 p_acb->sup_feature.mdep[i].ori_app_id = p_acb->app_id;
2415 APPL_TRACE_DEBUG("index %d ori_app_id %d", i,
2416 p_acb->sup_feature.mdep[i].ori_app_id);
2420 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2426 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2433 if ((status == BTA_HL_STATUS_OK) &&
2434 (p_acb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SOURCE))
2436 /* this is a source only applciation */
2437 p_acb->sup_feature.advertize_source_sdp =
2438 bta_hl_co_advrtise_source_sdp(p_acb->app_id);
2441 if ((status == BTA_HL_STATUS_OK)&&
2442 (!bta_hl_co_get_echo_config(p_acb->app_id, &p_acb->sup_feature.echo_cfg)))
2444 status = BTA_HL_STATUS_ECHO_CO_FAIL;
2447 if ((status == BTA_HL_STATUS_OK)&&
2448 (!bta_hl_co_load_mdl_config(p_acb->app_id, BTA_HL_NUM_MDL_CFGS, &p_acb->mdl_cfg[0])))
2450 status = BTA_HL_STATUS_MDL_CFG_CO_FAIL;
2455 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2460 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2463 if (status == BTA_HL_STATUS_OK)
2465 status = bta_hl_sdp_register(app_idx);
2472 /*******************************************************************************
2474 ** Function bta_hl_discard_data
2476 ** Description This function discard an HDP event
2480 *******************************************************************************/
2481 void bta_hl_discard_data(UINT16 event, tBTA_HL_DATA *p_data)
2484 #if BTA_HL_DEBUG == TRUE
2485 APPL_TRACE_ERROR("BTA HL Discard event=%s",bta_hl_evt_code(event));
2491 case BTA_HL_API_SEND_DATA_EVT:
2494 case BTA_HL_MCA_RCV_DATA_EVT:
2495 utl_freebuf((void**)&p_data->mca_rcv_data_evt.p_pkt);
2504 /*******************************************************************************
2506 ** Function bta_hl_save_mdl_cfg
2508 ** Description This function saves the MDL configuration
2512 *******************************************************************************/
2513 void bta_hl_save_mdl_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx )
2515 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2516 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2517 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2519 tBTA_HL_MDL_ID mdl_id;
2521 tBTA_HL_MDL_CFG mdl_cfg;
2522 tBTA_HL_MDEP *p_mdep_cfg;
2523 tBTA_HL_L2CAP_CFG_INFO l2cap_cfg;
2525 mdl_id = p_dcb->mdl_id;
2526 if (!bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, mdl_id, &mdl_cfg_idx))
2528 if (!bta_hl_find_avail_mdl_cfg_idx(app_idx, mcl_idx, &mdl_cfg_idx))
2530 APPL_TRACE_ERROR("No space to save the MDL config");
2531 found= FALSE; /*no space available*/
2537 bta_hl_get_l2cap_cfg(p_dcb->mdl_handle, &l2cap_cfg);
2538 if (!bta_hl_get_cur_time(app_idx, &time_val ))
2540 bta_hl_compact_mdl_cfg_time(app_idx,p_dcb->local_mdep_id);
2541 bta_hl_get_cur_time(app_idx, &time_val);
2543 mdl_cfg.active = TRUE;
2544 mdl_cfg.time = time_val;
2545 mdl_cfg.mdl_id = p_dcb->mdl_id;
2546 mdl_cfg.dch_mode = p_dcb->dch_mode;
2547 mdl_cfg.mtu = l2cap_cfg.mtu;
2548 mdl_cfg.fcs = l2cap_cfg.fcs;
2550 bdcpy(mdl_cfg.peer_bd_addr, p_mcb->bd_addr);
2551 mdl_cfg.local_mdep_id= p_dcb->local_mdep_id;
2552 p_mdep_cfg = &p_acb->sup_feature.mdep[p_dcb->local_mdep_cfg_idx];
2553 mdl_cfg.local_mdep_role= p_mdep_cfg->mdep_cfg.mdep_role;
2554 memcpy(&p_acb->mdl_cfg[mdl_cfg_idx], &mdl_cfg, sizeof(tBTA_HL_MDL_CFG));
2555 bta_hl_co_save_mdl(mdl_cfg.local_mdep_id, mdl_cfg_idx, &mdl_cfg);
2558 #if BTA_HL_DEBUG == TRUE
2561 if (p_dcb->mtu != l2cap_cfg.mtu)
2563 APPL_TRACE_WARNING("MCAP and L2CAP peer mtu size out of sync from MCAP mtu=%d from l2cap mtu=%d",
2564 p_dcb->mtu, l2cap_cfg.mtu);
2566 APPL_TRACE_DEBUG("bta_hl_save_mdl_cfg saved=%d", found);
2567 APPL_TRACE_DEBUG("Saved. L2cap cfg mdl_id=%d mtu=%d fcs=%d dch_mode=%d",
2568 mdl_cfg.mdl_id, mdl_cfg.mtu, mdl_cfg.fcs, mdl_cfg.dch_mode);
2576 /*******************************************************************************
2578 ** Function bta_hl_set_dch_chan_cfg
2580 ** Description This function setups the L2CAP DCH channel configuration
2583 *******************************************************************************/
2584 void bta_hl_set_dch_chan_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,tBTA_HL_DATA *p_data)
2586 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2587 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2588 UINT8 l2cap_mode = L2CAP_FCR_ERTM_MODE;
2589 tBTA_HL_SUP_FEATURE *p_sup_feature= &p_acb->sup_feature;
2590 UINT8 local_mdep_cfg_idx = p_dcb->local_mdep_cfg_idx;
2592 switch (p_dcb->dch_oper)
2594 case BTA_HL_DCH_OP_LOCAL_RECONNECT:
2595 case BTA_HL_DCH_OP_REMOTE_RECONNECT:
2596 if (p_dcb->dch_mode == BTA_HL_DCH_MODE_STREAMING)
2597 l2cap_mode = L2CAP_FCR_STREAM_MODE;
2599 case BTA_HL_DCH_OP_LOCAL_OPEN:
2600 if (p_data->mca_evt.mca_data.create_cfm.cfg == BTA_HL_DCH_CFG_STREAMING)
2601 l2cap_mode = L2CAP_FCR_STREAM_MODE;
2603 case BTA_HL_DCH_OP_REMOTE_OPEN:
2604 if (p_dcb->local_cfg == BTA_HL_DCH_CFG_STREAMING )
2605 l2cap_mode = L2CAP_FCR_STREAM_MODE;
2608 APPL_TRACE_ERROR("Invalid dch oper=%d for set dch chan cfg", p_dcb->dch_oper);
2611 p_dcb->chnl_cfg.fcr_opt.mode = l2cap_mode;
2612 p_dcb->chnl_cfg.fcr_opt.mps = bta_hl_set_mps(p_dcb->max_rx_apdu_size);
2613 p_dcb->chnl_cfg.fcr_opt.tx_win_sz = bta_hl_set_tx_win_size(p_dcb->max_rx_apdu_size,
2614 p_dcb->chnl_cfg.fcr_opt.mps);
2615 p_dcb->chnl_cfg.fcr_opt.max_transmit= BTA_HL_L2C_MAX_TRANSMIT;
2616 p_dcb->chnl_cfg.fcr_opt.rtrans_tout = BTA_HL_L2C_RTRANS_TOUT;
2617 p_dcb->chnl_cfg.fcr_opt.mon_tout = BTA_HL_L2C_MON_TOUT;
2619 p_dcb->chnl_cfg.user_rx_pool_id = bta_hl_set_user_rx_pool_id(p_dcb->max_rx_apdu_size);
2620 p_dcb->chnl_cfg.user_tx_pool_id = bta_hl_set_user_tx_pool_id(p_dcb->max_tx_apdu_size);
2621 p_dcb->chnl_cfg.fcr_rx_pool_id = BTA_HL_L2C_FCR_RX_POOL_ID;
2622 p_dcb->chnl_cfg.fcr_tx_pool_id = BTA_HL_L2C_FCR_TX_POOL_ID;
2623 p_dcb->chnl_cfg.data_mtu = p_dcb->max_rx_apdu_size;
2625 p_dcb->chnl_cfg.fcs = BTA_HL_MCA_NO_FCS;
2626 if (local_mdep_cfg_idx != BTA_HL_ECHO_TEST_MDEP_CFG_IDX)
2628 if (p_sup_feature->mdep[local_mdep_cfg_idx].mdep_cfg.mdep_role ==
2629 BTA_HL_MDEP_ROLE_SOURCE)
2631 p_dcb->chnl_cfg.fcs = BTA_HL_DEFAULT_SOURCE_FCS;
2636 p_dcb->chnl_cfg.fcs = BTA_HL_MCA_USE_FCS;
2639 #if BTA_HL_DEBUG == TRUE
2640 APPL_TRACE_DEBUG("L2CAP Params l2cap_mode[3-ERTM 4-STREAM]=%d", l2cap_mode);
2641 APPL_TRACE_DEBUG("Use FCS =%s mtu=%d", ((p_dcb->chnl_cfg.fcs & 1)?"YES":"NO"),
2642 p_dcb->chnl_cfg.data_mtu);
2643 APPL_TRACE_DEBUG("tx_win_sz=%d, max_transmit=%d, rtrans_tout=%d, mon_tout=%d, mps=%d",
2644 p_dcb->chnl_cfg.fcr_opt.tx_win_sz,
2645 p_dcb->chnl_cfg.fcr_opt.max_transmit,
2646 p_dcb->chnl_cfg.fcr_opt.rtrans_tout,
2647 p_dcb->chnl_cfg.fcr_opt.mon_tout,
2648 p_dcb->chnl_cfg.fcr_opt.mps);
2650 APPL_TRACE_DEBUG("USER rx_pool_id=%d, tx_pool_id=%d, FCR rx_pool_id=%d, tx_pool_id=%d",
2651 p_dcb->chnl_cfg.user_rx_pool_id,
2652 p_dcb->chnl_cfg.user_tx_pool_id,
2653 p_dcb->chnl_cfg.fcr_rx_pool_id,
2654 p_dcb->chnl_cfg.fcr_tx_pool_id);
2667 /*******************************************************************************
2669 ** Function bta_hl_get_l2cap_cfg
2671 ** Description This function get the current L2CAP channel configuration
2673 ** Returns BOOLEAN - TRUE - operation is successful
2674 *******************************************************************************/
2675 BOOLEAN bta_hl_get_l2cap_cfg(tBTA_HL_MDL_HANDLE mdl_hnd, tBTA_HL_L2CAP_CFG_INFO *p_cfg)
2677 BOOLEAN success = FALSE;
2679 tL2CAP_CFG_INFO *p_our_cfg;
2680 tL2CAP_CH_CFG_BITS our_cfg_bits;
2681 tL2CAP_CFG_INFO *p_peer_cfg;
2682 tL2CAP_CH_CFG_BITS peer_cfg_bits;
2684 lcid = MCA_GetL2CapChannel((tMCA_DL) mdl_hnd);
2686 L2CA_GetCurrentConfig(lcid, &p_our_cfg, &our_cfg_bits, &p_peer_cfg,
2689 p_cfg->fcs = BTA_HL_MCA_NO_FCS;
2690 if (our_cfg_bits & L2CAP_CH_CFG_MASK_FCS)
2692 p_cfg->fcs |= p_our_cfg->fcs;
2696 p_cfg->fcs = BTA_HL_MCA_USE_FCS;
2699 if (p_cfg->fcs != BTA_HL_MCA_USE_FCS )
2701 if (peer_cfg_bits & L2CAP_CH_CFG_MASK_FCS)
2703 p_cfg->fcs |= p_peer_cfg->fcs;
2707 p_cfg->fcs = BTA_HL_MCA_USE_FCS;
2712 if (peer_cfg_bits & L2CAP_CH_CFG_MASK_MTU)
2714 p_cfg->mtu = p_peer_cfg->mtu;
2718 p_cfg->mtu = L2CAP_DEFAULT_MTU;
2724 p_cfg->mtu = L2CAP_DEFAULT_MTU;
2725 p_cfg->fcs = BTA_HL_L2C_NO_FCS;
2728 #if BTA_HL_DEBUG == TRUE
2731 APPL_TRACE_DEBUG("bta_hl_get_l2cap_cfg success=%d mdl=%d lcid=%d", success, mdl_hnd, lcid);
2732 APPL_TRACE_DEBUG("l2cap mtu=%d fcs=%d", p_cfg->mtu, p_cfg->fcs);
2739 /*******************************************************************************
2741 ** Function bta_hl_validate_chan_cfg
2743 ** Description This function validates the L2CAP channel configuration
2745 ** Returns BOOLEAN - TRUE - validation is successful
2746 *******************************************************************************/
2747 BOOLEAN bta_hl_validate_chan_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx)
2749 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2750 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2751 BOOLEAN success = FALSE;
2752 UINT8 mdl_cfg_idx = 0;
2753 tBTA_HL_L2CAP_CFG_INFO l2cap_cfg;
2754 BOOLEAN get_l2cap_result, get_mdl_result;
2756 get_l2cap_result = bta_hl_get_l2cap_cfg(p_dcb->mdl_handle, &l2cap_cfg);
2757 get_mdl_result = bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, p_dcb->mdl_id, &mdl_cfg_idx);
2759 if (get_l2cap_result && get_mdl_result)
2761 if ((p_acb->mdl_cfg[mdl_cfg_idx].mtu <= l2cap_cfg.mtu) &&
2762 (p_acb->mdl_cfg[mdl_cfg_idx].fcs == l2cap_cfg.fcs) &&
2763 (p_acb->mdl_cfg[mdl_cfg_idx].dch_mode == p_dcb->dch_mode))
2770 #if BTA_HL_DEBUG == TRUE
2772 if (p_dcb->mtu != l2cap_cfg.mtu)
2774 APPL_TRACE_WARNING("MCAP and L2CAP peer mtu size out of sync from MCAP mtu=%d from l2cap mtu=%d",
2775 p_dcb->mtu, l2cap_cfg.mtu);
2780 APPL_TRACE_DEBUG("bta_hl_validate_chan_cfg success=%d app_idx=%d mcl_idx=%d mdl_idx=%d",success, app_idx, mcl_idx, mdl_idx);
2781 APPL_TRACE_DEBUG("Cur. L2cap cfg mtu=%d fcs=%d dch_mode=%d", l2cap_cfg.mtu, l2cap_cfg.fcs, p_dcb->dch_mode);
2782 APPL_TRACE_DEBUG("From saved: L2cap cfg mtu=%d fcs=%d dch_mode=%d", p_acb->mdl_cfg[mdl_cfg_idx].mtu,
2783 p_acb->mdl_cfg[mdl_cfg_idx].fcs , p_acb->mdl_cfg[mdl_cfg_idx].dch_mode);
2791 /*******************************************************************************
2793 ** Function bta_hl_is_cong_on
2795 ** Description This function checks whether the congestion condition is on or not
2797 ** Returns BOOLEAN - TRUE DCH is congested
2798 ** FALSE not congested
2800 *******************************************************************************/
2801 BOOLEAN bta_hl_is_cong_on(UINT8 app_id, BD_ADDR bd_addr, tBTA_HL_MDL_ID mdl_id)
2804 tBTA_HL_MDL_CB *p_dcb;
2805 UINT8 app_idx = 0, mcl_idx, mdl_idx;
2806 BOOLEAN cong_status = TRUE;
2808 if (bta_hl_find_app_idx(app_id, &app_idx))
2810 if (bta_hl_find_mcl_idx(app_idx, bd_addr, &mcl_idx ))
2812 if (bta_hl_find_mdl_idx(app_idx, mcl_idx, mdl_id, &mdl_idx ))
2814 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2815 cong_status = p_dcb->cong;
2823 /*******************************************************************************
2825 ** Function bta_hl_check_cch_close
2827 ** Description This function checks whether there is a pending CCH close request
2831 *******************************************************************************/
2832 void bta_hl_check_cch_close(UINT8 app_idx, UINT8 mcl_idx, tBTA_HL_DATA *p_data, BOOLEAN check_dch_setup )
2834 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2835 tBTA_HL_MDL_CB *p_dcb;
2838 #if (BTA_HL_DEBUG == TRUE)
2839 APPL_TRACE_DEBUG("bta_hl_check_cch_close cch_close_dch_oper=%d",p_mcb->cch_close_dch_oper );
2842 if (p_mcb->cch_oper == BTA_HL_CCH_OP_LOCAL_CLOSE)
2844 if (check_dch_setup && bta_hl_find_dch_setup_mdl_idx(app_idx, mcl_idx, &mdl_idx))
2846 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2847 if (!p_mcb->rsp_tout)
2849 p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_ABORT;
2851 if (!p_dcb->abort_oper)
2853 p_dcb->abort_oper |= BTA_HL_ABORT_CCH_CLOSE_MASK;
2854 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_ABORT_EVT, p_data);
2859 p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_CLOSE;
2860 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
2863 else if (bta_hl_find_an_active_mdl_idx(app_idx, mcl_idx,&mdl_idx))
2865 p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_CLOSE;
2866 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_EVT, p_data);
2870 p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_NONE;
2871 bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_CLOSE_EVT, p_data);
2876 /*******************************************************************************
2878 ** Function bta_hl_clean_app
2880 ** Description Cleans up the HDP application resources and control block
2884 *******************************************************************************/
2885 void bta_hl_clean_app(UINT8 app_idx)
2887 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2888 int i, num_act_apps=0;
2890 #if BTA_HL_DEBUG == TRUE
2891 APPL_TRACE_DEBUG("bta_hl_clean_app");
2893 MCA_Deregister((tMCA_HANDLE)p_acb->app_handle);
2895 if (p_acb->sdp_handle) SDP_DeleteRecord(p_acb->sdp_handle);
2897 memset((void *) p_acb, 0, sizeof(tBTA_HL_APP_CB));
2899 /* check any application is still active */
2900 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
2902 p_acb = BTA_HL_GET_APP_CB_PTR(i);
2903 if (p_acb->in_use) num_act_apps++;
2908 bta_sys_remove_uuid(UUID_SERVCLASS_HDP_PROFILE);
2912 /*******************************************************************************
2914 ** Function bta_hl_check_deregistration
2916 ** Description This function checks whether there is a pending deregistration
2920 *******************************************************************************/
2921 void bta_hl_check_deregistration(UINT8 app_idx, tBTA_HL_DATA *p_data )
2923 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2924 tBTA_HL_MCL_CB *p_mcb;
2928 #if (BTA_HL_DEBUG == TRUE)
2929 APPL_TRACE_DEBUG("bta_hl_check_deregistration");
2932 if (p_acb->deregistering)
2934 if (bta_hl_find_an_in_use_mcl_idx(app_idx, &mcl_idx))
2936 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2937 if (p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_CLOSE)
2939 if (p_mcb->cch_state == BTA_HL_CCH_OPENING_ST)
2940 p_mcb->force_close_local_cch_opening = TRUE;
2941 p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_CLOSE;
2942 APPL_TRACE_DEBUG("p_mcb->force_close_local_cch_opening=%d", p_mcb->force_close_local_cch_opening );
2943 bta_hl_check_cch_close(app_idx,mcl_idx,p_data, TRUE);
2948 /* all cchs are closed */
2949 evt_data.dereg_cfm.app_handle = p_acb->app_handle;
2950 evt_data.dereg_cfm.app_id = p_data->api_dereg.app_id;
2951 evt_data.dereg_cfm.status = BTA_HL_STATUS_OK;
2952 p_acb->p_cback(BTA_HL_DEREGISTER_CFM_EVT, (tBTA_HL *) &evt_data );
2953 bta_hl_clean_app(app_idx);
2954 bta_hl_check_disable(p_data);
2960 /*******************************************************************************
2962 ** Function bta_hl_check_disable
2964 ** Description This function checks whether there is a pending disable
2969 *******************************************************************************/
2970 void bta_hl_check_disable(tBTA_HL_DATA *p_data )
2972 tBTA_HL_CB *p_cb= &bta_hl_cb;
2973 tBTA_HL_APP_CB *p_acb;
2975 tBTA_HL_CTRL evt_data;
2977 #if (BTA_HL_DEBUG == TRUE)
2978 APPL_TRACE_DEBUG("bta_hl_check_disable");
2981 if (bta_hl_cb.disabling)
2983 if (bta_hl_find_an_in_use_app_idx(&app_idx))
2985 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2986 if (!p_acb->deregistering)
2988 p_acb->deregistering = TRUE;
2989 bta_hl_check_deregistration(app_idx, p_data);
2994 /* all apps are deregistered */
2995 bta_sys_deregister(BTA_ID_HL);
2996 evt_data.disable_cfm.status = BTA_HL_STATUS_OK;
2997 if (p_cb->p_ctrl_cback) p_cb->p_ctrl_cback(BTA_HL_CTRL_DISABLE_CFM_EVT, (tBTA_HL_CTRL *) &evt_data);
2998 memset((void *) p_cb, 0, sizeof(tBTA_HL_CB));
3003 /*******************************************************************************
3005 ** Function bta_hl_build_abort_cfm
3007 ** Description This function builds the abort confirmation event data
3011 *******************************************************************************/
3012 void bta_hl_build_abort_cfm(tBTA_HL *p_evt_data,
3013 tBTA_HL_APP_HANDLE app_handle,
3014 tBTA_HL_MCL_HANDLE mcl_handle,
3015 tBTA_HL_STATUS status)
3017 p_evt_data->dch_abort_cfm.status = status;
3018 p_evt_data->dch_abort_cfm.mcl_handle = mcl_handle;
3019 p_evt_data->dch_abort_cfm.app_handle = app_handle;
3022 /*******************************************************************************
3024 ** Function bta_hl_build_abort_ind
3026 ** Description This function builds the abort indication event data
3030 *******************************************************************************/
3031 void bta_hl_build_abort_ind(tBTA_HL *p_evt_data,
3032 tBTA_HL_APP_HANDLE app_handle,
3033 tBTA_HL_MCL_HANDLE mcl_handle)
3035 p_evt_data->dch_abort_ind.mcl_handle = mcl_handle;
3036 p_evt_data->dch_abort_ind.app_handle = app_handle;
3038 /*******************************************************************************
3040 ** Function bta_hl_build_close_cfm
3042 ** Description This function builds the close confirmation event data
3046 *******************************************************************************/
3047 void bta_hl_build_dch_close_cfm(tBTA_HL *p_evt_data,
3048 tBTA_HL_APP_HANDLE app_handle,
3049 tBTA_HL_MCL_HANDLE mcl_handle,
3050 tBTA_HL_MDL_HANDLE mdl_handle,
3051 tBTA_HL_STATUS status)
3053 p_evt_data->dch_close_cfm.status = status;
3054 p_evt_data->dch_close_cfm.mdl_handle = mdl_handle;
3055 p_evt_data->dch_close_cfm.mcl_handle = mcl_handle;
3056 p_evt_data->dch_close_cfm.app_handle = app_handle;
3059 /*******************************************************************************
3061 ** Function bta_hl_build_dch_close_ind
3063 ** Description This function builds the close indication event data
3067 *******************************************************************************/
3068 void bta_hl_build_dch_close_ind(tBTA_HL *p_evt_data,
3069 tBTA_HL_APP_HANDLE app_handle,
3070 tBTA_HL_MCL_HANDLE mcl_handle,
3071 tBTA_HL_MDL_HANDLE mdl_handle,
3072 BOOLEAN intentional)
3074 p_evt_data->dch_close_ind.mdl_handle = mdl_handle;
3075 p_evt_data->dch_close_ind.mcl_handle = mcl_handle;
3076 p_evt_data->dch_close_ind.app_handle = app_handle;
3077 p_evt_data->dch_close_ind.intentional = intentional;
3080 /*******************************************************************************
3082 ** Function bta_hl_build_send_data_cfm
3084 ** Description This function builds the send data confirmation event data
3088 *******************************************************************************/
3089 void bta_hl_build_send_data_cfm(tBTA_HL *p_evt_data,
3090 tBTA_HL_APP_HANDLE app_handle,
3091 tBTA_HL_MCL_HANDLE mcl_handle,
3092 tBTA_HL_MDL_HANDLE mdl_handle,
3093 tBTA_HL_STATUS status )
3096 p_evt_data->dch_send_data_cfm.mdl_handle = mdl_handle;
3097 p_evt_data->dch_send_data_cfm.mcl_handle = mcl_handle;
3098 p_evt_data->dch_send_data_cfm.app_handle = app_handle;
3099 p_evt_data->dch_send_data_cfm.status = status;
3102 /*******************************************************************************
3104 ** Function bta_hl_build_rcv_data_ind
3106 ** Description This function builds the received data indication event data
3110 *******************************************************************************/
3111 void bta_hl_build_rcv_data_ind(tBTA_HL *p_evt_data,
3112 tBTA_HL_APP_HANDLE app_handle,
3113 tBTA_HL_MCL_HANDLE mcl_handle,
3114 tBTA_HL_MDL_HANDLE mdl_handle)
3116 p_evt_data->dch_rcv_data_ind.mdl_handle = mdl_handle;
3117 p_evt_data->dch_rcv_data_ind.mcl_handle = mcl_handle;
3118 p_evt_data->dch_rcv_data_ind.app_handle = app_handle;
3122 /*******************************************************************************
3124 ** Function bta_hl_build_cch_open_cfm
3126 ** Description This function builds the CCH open confirmation event data
3130 *******************************************************************************/
3131 void bta_hl_build_cch_open_cfm(tBTA_HL *p_evt_data,
3133 tBTA_HL_APP_HANDLE app_handle,
3134 tBTA_HL_MCL_HANDLE mcl_handle,
3136 tBTA_HL_STATUS status )
3138 p_evt_data->cch_open_cfm.app_id = app_id;
3139 p_evt_data->cch_open_cfm.app_handle = app_handle;
3140 p_evt_data->cch_open_cfm.mcl_handle = mcl_handle;
3141 bdcpy(p_evt_data->cch_open_cfm.bd_addr, bd_addr);
3142 p_evt_data->cch_open_cfm.status = status;
3143 APPL_TRACE_DEBUG("bta_hl_build_cch_open_cfm: status=%d",status);
3146 /*******************************************************************************
3148 ** Function bta_hl_build_cch_open_ind
3150 ** Description This function builds the CCH open indication event data
3154 *******************************************************************************/
3155 void bta_hl_build_cch_open_ind(tBTA_HL *p_evt_data, tBTA_HL_APP_HANDLE app_handle,
3156 tBTA_HL_MCL_HANDLE mcl_handle,
3160 p_evt_data->cch_open_ind.app_handle = app_handle;
3161 p_evt_data->cch_open_ind.mcl_handle = mcl_handle;
3162 bdcpy(p_evt_data->cch_open_ind.bd_addr, bd_addr);
3165 /*******************************************************************************
3167 ** Function bta_hl_build_cch_close_cfm
3169 ** Description This function builds the CCH close confirmation event data
3173 *******************************************************************************/
3174 void bta_hl_build_cch_close_cfm(tBTA_HL *p_evt_data,
3175 tBTA_HL_APP_HANDLE app_handle,
3176 tBTA_HL_MCL_HANDLE mcl_handle,
3177 tBTA_HL_STATUS status )
3179 p_evt_data->cch_close_cfm.mcl_handle = mcl_handle;
3180 p_evt_data->cch_close_cfm.app_handle = app_handle;
3181 p_evt_data->cch_close_cfm.status = status;
3185 /*******************************************************************************
3187 ** Function bta_hl_build_cch_close_ind
3189 ** Description This function builds the CCH colse indication event data
3193 *******************************************************************************/
3194 void bta_hl_build_cch_close_ind(tBTA_HL *p_evt_data,
3195 tBTA_HL_APP_HANDLE app_handle,
3196 tBTA_HL_MCL_HANDLE mcl_handle,
3197 BOOLEAN intentional)
3199 p_evt_data->cch_close_ind.mcl_handle = mcl_handle;
3200 p_evt_data->cch_close_ind.app_handle = app_handle;
3201 p_evt_data->cch_close_ind.intentional = intentional;
3204 /*******************************************************************************
3206 ** Function bta_hl_build_dch_open_cfm
3208 ** Description This function builds the DCH open confirmation event data
3212 *******************************************************************************/
3213 void bta_hl_build_dch_open_cfm(tBTA_HL *p_evt_data,
3214 tBTA_HL_APP_HANDLE app_handle,
3215 tBTA_HL_MCL_HANDLE mcl_handle,
3216 tBTA_HL_MDL_HANDLE mdl_handle,
3217 tBTA_HL_MDEP_ID local_mdep_id,
3218 tBTA_HL_MDL_ID mdl_id,
3219 tBTA_HL_DCH_MODE dch_mode,
3220 BOOLEAN first_reliable,
3222 tBTA_HL_STATUS status)
3225 p_evt_data->dch_open_cfm.mdl_handle = mdl_handle;
3226 p_evt_data->dch_open_cfm.mcl_handle = mcl_handle;
3227 p_evt_data->dch_open_cfm.app_handle = app_handle;
3228 p_evt_data->dch_open_cfm.local_mdep_id = local_mdep_id;
3229 p_evt_data->dch_open_cfm.mdl_id = mdl_id;
3230 p_evt_data->dch_open_cfm.dch_mode = dch_mode;
3231 p_evt_data->dch_open_cfm.first_reliable = first_reliable;
3232 p_evt_data->dch_open_cfm.mtu = mtu;
3233 p_evt_data->dch_open_cfm.status = status;
3237 /*******************************************************************************
3239 ** Function bta_hl_build_sdp_query_cfm
3241 ** Description This function builds the SDP query indication event data
3245 *******************************************************************************/
3246 void bta_hl_build_sdp_query_cfm(tBTA_HL *p_evt_data,
3248 tBTA_HL_APP_HANDLE app_handle,
3251 tBTA_HL_STATUS status)
3254 APPL_TRACE_DEBUG("bta_hl_build_sdp_query_cfm: app_id = %d, app_handle=%d",
3256 p_evt_data->sdp_query_cfm.app_id = app_id;
3257 p_evt_data->sdp_query_cfm.app_handle = app_handle;
3258 bdcpy(p_evt_data->sdp_query_cfm.bd_addr, bd_addr);
3259 p_evt_data->sdp_query_cfm.p_sdp = p_sdp;
3260 p_evt_data->sdp_query_cfm.status = status;
3264 /*******************************************************************************
3266 ** Function bta_hl_build_delete_mdl_cfm
3268 ** Description This function builds the delete MDL confirmation event data
3272 *******************************************************************************/
3273 void bta_hl_build_delete_mdl_cfm(tBTA_HL *p_evt_data,
3274 tBTA_HL_APP_HANDLE app_handle,
3275 tBTA_HL_MCL_HANDLE mcl_handle,
3276 tBTA_HL_MDL_ID mdl_id,
3277 tBTA_HL_STATUS status)
3280 p_evt_data->delete_mdl_cfm.mcl_handle = mcl_handle;
3281 p_evt_data->delete_mdl_cfm.app_handle = app_handle;
3282 p_evt_data->delete_mdl_cfm.mdl_id = mdl_id;
3283 p_evt_data->delete_mdl_cfm.status = status;
3286 /*******************************************************************************
3288 ** Function bta_hl_build_echo_test_cfm
3290 ** Description This function builds the echo test confirmation event data
3294 *******************************************************************************/
3295 void bta_hl_build_echo_test_cfm(tBTA_HL *p_evt_data,
3296 tBTA_HL_APP_HANDLE app_handle,
3297 tBTA_HL_MCL_HANDLE mcl_handle,
3298 tBTA_HL_STATUS status )
3300 p_evt_data->echo_test_cfm.mcl_handle = mcl_handle;
3301 p_evt_data->echo_test_cfm.app_handle = app_handle;
3302 p_evt_data->echo_test_cfm.status = status;
3306 /*****************************************************************************
3308 *****************************************************************************/
3309 #if (BTA_HL_DEBUG == TRUE)
3311 /*******************************************************************************
3313 ** Function bta_hl_status_code
3315 ** Description get the status string pointer
3317 ** Returns char * - status string pointer
3319 *******************************************************************************/
3320 char *bta_hl_status_code(tBTA_HL_STATUS status)
3324 case BTA_HL_STATUS_OK:
3325 return "BTA_HL_STATUS_OK";
3326 case BTA_HL_STATUS_FAIL:
3327 return "BTA_HL_STATUS_FAIL";
3328 case BTA_HL_STATUS_ABORTED:
3329 return "BTA_HL_STATUS_ABORTED";
3330 case BTA_HL_STATUS_NO_RESOURCE:
3331 return "BTA_HL_STATUS_NO_RESOURCE";
3332 case BTA_HL_STATUS_LAST_ITEM:
3333 return "BTA_HL_STATUS_LAST_ITEM";
3334 case BTA_HL_STATUS_DUPLICATE_APP_ID:
3335 return "BTA_HL_STATUS_DUPLICATE_APP_ID";
3336 case BTA_HL_STATUS_INVALID_APP_HANDLE:
3337 return "BTA_HL_STATUS_INVALID_APP_HANDLE";
3338 case BTA_HL_STATUS_INVALID_MCL_HANDLE:
3339 return "BTA_HL_STATUS_INVALID_MCL_HANDLE";
3340 case BTA_HL_STATUS_MCAP_REG_FAIL:
3341 return "BTA_HL_STATUS_MCAP_REG_FAIL";
3342 case BTA_HL_STATUS_MDEP_CO_FAIL:
3343 return "BTA_HL_STATUS_MDEP_CO_FAIL";
3344 case BTA_HL_STATUS_ECHO_CO_FAIL:
3345 return "BTA_HL_STATUS_ECHO_CO_FAIL";
3346 case BTA_HL_STATUS_MDL_CFG_CO_FAIL:
3347 return "BTA_HL_STATUS_MDL_CFG_CO_FAIL";
3348 case BTA_HL_STATUS_SDP_NO_RESOURCE:
3349 return "BTA_HL_STATUS_SDP_NO_RESOURCE";
3350 case BTA_HL_STATUS_SDP_FAIL:
3351 return "BTA_HL_STATUS_SDP_FAIL";
3352 case BTA_HL_STATUS_NO_CCH:
3353 return "BTA_HL_STATUS_NO_CCH";
3354 case BTA_HL_STATUS_NO_MCL:
3355 return "BTA_HL_STATUS_NO_MCL";
3357 case BTA_HL_STATUS_NO_FIRST_RELIABLE:
3358 return "BTA_HL_STATUS_NO_FIRST_RELIABLE";
3359 case BTA_HL_STATUS_INVALID_DCH_CFG:
3360 return "BTA_HL_STATUS_INVALID_DCH_CFG";
3361 case BTA_HL_STATUS_INVALID_BD_ADDR:
3362 return "BTA_HL_STATUS_INVALID_BD_ADDR";
3363 case BTA_HL_STATUS_INVALID_RECONNECT_CFG:
3364 return "BTA_HL_STATUS_INVALID_RECONNECT_CFG";
3365 case BTA_HL_STATUS_ECHO_TEST_BUSY:
3366 return "BTA_HL_STATUS_ECHO_TEST_BUSY";
3367 case BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID:
3368 return "BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID";
3369 case BTA_HL_STATUS_INVALID_MDL_ID:
3370 return "BTA_HL_STATUS_INVALID_MDL_ID";
3371 case BTA_HL_STATUS_NO_MDL_ID_FOUND:
3372 return "BTA_HL_STATUS_NO_MDL_ID_FOUND";
3373 case BTA_HL_STATUS_DCH_BUSY:
3374 return "BTA_HL_STATUS_DCH_BUSY";
3376 return "Unknown status code";
3379 /*******************************************************************************
3381 ** Function bta_hl_evt_code
3383 ** Description Maps HL event code to the corresponding event string
3385 ** Returns string pointer for the associated event name
3387 *******************************************************************************/
3388 char *bta_hl_evt_code(tBTA_HL_INT_EVT evt_code)
3392 case BTA_HL_CCH_OPEN_EVT:
3393 return "BTA_HL_CCH_OPEN_EVT";
3394 case BTA_HL_CCH_SDP_OK_EVT:
3395 return "BTA_HL_CCH_SDP_OK_EVT";
3396 case BTA_HL_CCH_SDP_FAIL_EVT:
3397 return "BTA_HL_CCH_SDP_FAIL_EVT";
3398 case BTA_HL_MCA_CONNECT_IND_EVT:
3399 return "BTA_HL_MCA_CONNECT_IND_EVT";
3400 case BTA_HL_MCA_DISCONNECT_IND_EVT:
3401 return "BTA_HL_MCA_DISCONNECT_IND_EVT";
3403 case BTA_HL_CCH_CLOSE_EVT:
3404 return "BTA_HL_CCH_CLOSE_EVT";
3405 case BTA_HL_CCH_CLOSE_CMPL_EVT:
3406 return "BTA_HL_CCH_CLOSE_CMPL_EVT";
3407 case BTA_HL_DCH_OPEN_EVT:
3408 return "BTA_HL_DCH_OPEN_EVT";
3409 case BTA_HL_MCA_CREATE_IND_EVT:
3410 return "BTA_HL_MCA_CREATE_IND_EVT";
3411 case BTA_HL_MCA_CREATE_CFM_EVT:
3412 return "BTA_HL_MCA_CREATE_CFM_EVT";
3413 case BTA_HL_MCA_OPEN_IND_EVT:
3414 return "BTA_HL_MCA_OPEN_IND_EVT";
3415 case BTA_HL_MCA_OPEN_CFM_EVT:
3416 return "BTA_HL_MCA_OPEN_CFM_EVT";
3417 case BTA_HL_DCH_CLOSE_EVT:
3418 return "BTA_HL_DCH_CLOSE_EVT";
3419 case BTA_HL_MCA_CLOSE_IND_EVT:
3420 return "BTA_HL_MCA_CLOSE_IND_EVT";
3421 case BTA_HL_MCA_CLOSE_CFM_EVT:
3422 return "BTA_HL_MCA_CLOSE_CFM_EVT";
3423 case BTA_HL_API_SEND_DATA_EVT:
3424 return "BTA_HL_API_SEND_DATA_EVT";
3425 case BTA_HL_MCA_RCV_DATA_EVT:
3426 return "BTA_HL_MCA_RCV_DATA_EVT";
3427 case BTA_HL_DCH_CLOSE_CMPL_EVT:
3428 return "BTA_HL_DCH_CLOSE_CMPL_EVT";
3430 case BTA_HL_API_ENABLE_EVT:
3431 return "BTA_HL_API_ENABLE_EVT";
3432 case BTA_HL_API_DISABLE_EVT:
3433 return "BTA_HL_API_DISABLE_EVT";
3434 case BTA_HL_API_UPDATE_EVT:
3435 return "BTA_HL_API_UPDATE_EVT";
3436 case BTA_HL_API_REGISTER_EVT:
3437 return "BTA_HL_API_REGISTER_EVT";
3438 case BTA_HL_API_DEREGISTER_EVT:
3439 return "BTA_HL_API_DEREGISTER_EVT";
3441 case BTA_HL_API_CCH_OPEN_EVT:
3442 return "BTA_HL_API_CCH_OPEN_EVT";
3444 case BTA_HL_API_CCH_CLOSE_EVT:
3445 return "BTA_HL_API_CCH_CLOSE_EVT";
3446 case BTA_HL_API_DCH_OPEN_EVT:
3447 return "BTA_HL_API_DCH_OPEN_EVT";
3449 case BTA_HL_API_DCH_RECONNECT_EVT:
3450 return "BTA_HL_API_DCH_RECONNECT_EVT";
3451 case BTA_HL_API_DCH_CLOSE_EVT:
3452 return "BTA_HL_API_DCH_CLOSE_EVT";
3453 case BTA_HL_API_DELETE_MDL_EVT:
3454 return "BTA_HL_API_DELETE_MDL_EVT";
3455 case BTA_HL_API_DCH_ABORT_EVT:
3456 return "BTA_HL_API_DCH_ABORT_EVT";
3458 case BTA_HL_DCH_RECONNECT_EVT:
3459 return "BTA_HL_DCH_RECONNECT_EVT";
3460 case BTA_HL_DCH_SDP_INIT_EVT:
3461 return "BTA_HL_DCH_SDP_INIT_EVT";
3462 case BTA_HL_DCH_SDP_FAIL_EVT:
3463 return "BTA_HL_DCH_SDP_FAIL_EVT";
3464 case BTA_HL_API_DCH_ECHO_TEST_EVT:
3465 return "BTA_HL_API_DCH_ECHO_TEST_EVT";
3466 case BTA_HL_DCH_CLOSE_ECHO_TEST_EVT:
3467 return "BTA_HL_DCH_CLOSE_ECHO_TEST_EVT";
3468 case BTA_HL_MCA_RECONNECT_IND_EVT:
3469 return "BTA_HL_MCA_RECONNECT_IND_EVT";
3470 case BTA_HL_MCA_RECONNECT_CFM_EVT:
3471 return "BTA_HL_MCA_RECONNECT_CFM_EVT";
3472 case BTA_HL_API_DCH_CREATE_RSP_EVT:
3473 return "BTA_HL_API_DCH_CREATE_RSP_EVT";
3474 case BTA_HL_DCH_ABORT_EVT:
3475 return "BTA_HL_DCH_ABORT_EVT";
3476 case BTA_HL_MCA_ABORT_IND_EVT:
3477 return "BTA_HL_MCA_ABORT_IND_EVT";
3478 case BTA_HL_MCA_ABORT_CFM_EVT:
3479 return "BTA_HL_MCA_ABORT_CFM_EVT";
3480 case BTA_HL_MCA_DELETE_IND_EVT:
3481 return "BTA_HL_MCA_DELETE_IND_EVT";
3482 case BTA_HL_MCA_DELETE_CFM_EVT:
3483 return "BTA_HL_MCA_DELETE_CFM_EVT";
3484 case BTA_HL_MCA_CONG_CHG_EVT:
3485 return "BTA_HL_MCA_CONG_CHG_EVT";
3486 case BTA_HL_CI_GET_TX_DATA_EVT:
3487 return "BTA_HL_CI_GET_TX_DATA_EVT";
3488 case BTA_HL_CI_PUT_RX_DATA_EVT:
3489 return "BTA_HL_CI_PUT_RX_DATA_EVT";
3490 case BTA_HL_CI_GET_ECHO_DATA_EVT:
3491 return "BTA_HL_CI_GET_ECHO_DATA_EVT";
3492 case BTA_HL_DCH_ECHO_TEST_EVT:
3493 return "BTA_HL_DCH_ECHO_TEST_EVT";
3494 case BTA_HL_CI_PUT_ECHO_DATA_EVT:
3495 return "BTA_HL_CI_PUT_ECHO_DATA_EVT";
3496 case BTA_HL_API_SDP_QUERY_EVT:
3497 return "BTA_HL_API_SDP_QUERY_EVT";
3498 case BTA_HL_SDP_QUERY_OK_EVT:
3499 return "BTA_HL_SDP_QUERY_OK_EVT";
3500 case BTA_HL_SDP_QUERY_FAIL_EVT:
3501 return "BTA_HL_SDP_QUERY_FAIL_EVT";
3502 case BTA_HL_MCA_RSP_TOUT_IND_EVT:
3503 return "BTA_HL_MCA_RSP_TOUT_IND_EVT";
3506 return "Unknown HL event code";
3510 #endif /* Debug Functions */
3511 #endif // HL_INCLUDED