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)
36 #include "bta_hl_int.h"
37 #include "bta_hl_co.h"
42 /*******************************************************************************
44 ** Function bta_hl_set_ctrl_psm_for_dch
46 ** Description This function set the control PSM for the DCH setup
48 ** Returns BOOLEAN - TRUE - control PSM setting is successful
49 *******************************************************************************/
50 BOOLEAN bta_hl_set_ctrl_psm_for_dch(UINT8 app_idx, UINT8 mcl_idx,
51 UINT8 mdl_idx, UINT16 ctrl_psm)
53 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
54 BOOLEAN success = TRUE, update_ctrl_psm = FALSE;
57 if (p_mcb->sdp.num_recs)
59 if (p_mcb->ctrl_psm != ctrl_psm)
61 /* can not use a different ctrl PSM than the current one*/
67 /* No SDP info control i.e. channel was opened by the peer */
68 update_ctrl_psm = TRUE;
71 if (success && update_ctrl_psm)
73 p_mcb->ctrl_psm = ctrl_psm;
77 #if BTA_HL_DEBUG == TRUE
80 APPL_TRACE_DEBUG("bta_hl_set_ctrl_psm_for_dch num_recs=%d success=%d update_ctrl_psm=%d ctrl_psm=0x%x ",
81 p_mcb->sdp.num_recs, success, update_ctrl_psm, ctrl_psm );
89 /*******************************************************************************
91 ** Function bta_hl_find_sdp_idx_using_ctrl_psm
95 ** Returns UINT8 pool_id
97 *******************************************************************************/
98 BOOLEAN bta_hl_find_sdp_idx_using_ctrl_psm(tBTA_HL_SDP *p_sdp,
103 tBTA_HL_SDP_REC *p_rec;
108 for (i=0; i<p_sdp->num_recs; i++)
110 p_rec = &p_sdp->sdp_rec[i];
111 if (p_rec->ctrl_psm == ctrl_psm)
125 #if BTA_HL_DEBUG == TRUE
128 APPL_TRACE_DEBUG("bta_hl_find_sdp_idx_using_ctrl_psm found=%d sdp_idx=%d ctrl_psm=0x%x ",
129 found, *p_sdp_idx, ctrl_psm );
135 /*******************************************************************************
137 ** Function bta_hl_set_user_tx_pool_id
139 ** Description This function sets the user tx pool id
141 ** Returns UINT8 pool_id
143 *******************************************************************************/
145 UINT8 bta_hl_set_user_tx_pool_id(UINT16 max_tx_size)
149 if (max_tx_size > GKI_get_pool_bufsize (HCI_ACL_POOL_ID))
151 pool_id = BTA_HL_LRG_DATA_POOL_ID;
155 pool_id = L2CAP_DEFAULT_ERM_POOL_ID;
158 #if BTA_HL_DEBUG == TRUE
159 APPL_TRACE_DEBUG("bta_hl_set_user_rx_pool_id pool_id=%d max_tx_size=%d default_ertm_pool_size=%d",
160 pool_id, max_tx_size, GKI_get_pool_bufsize (HCI_ACL_POOL_ID));
166 /*******************************************************************************
168 ** Function bta_hl_set_user_rx_pool_id
170 ** Description This function sets the user trx pool id
172 ** Returns UINT8 pool_id
174 *******************************************************************************/
176 UINT8 bta_hl_set_user_rx_pool_id(UINT16 mtu)
180 if (mtu > GKI_get_pool_bufsize (HCI_ACL_POOL_ID))
182 pool_id = BTA_HL_LRG_DATA_POOL_ID;
186 pool_id = L2CAP_DEFAULT_ERM_POOL_ID;
189 #if BTA_HL_DEBUG == TRUE
190 APPL_TRACE_DEBUG("bta_hl_set_user_rx_pool_id pool_id=%d mtu=%d default_ertm_pool_size=%d",
191 pool_id, mtu, GKI_get_pool_bufsize (HCI_ACL_POOL_ID));
199 /*******************************************************************************
201 ** Function bta_hl_set_tx_win_size
203 ** Description This function sets the tx window size
205 ** Returns UINT8 tx_win_size
207 *******************************************************************************/
208 UINT8 bta_hl_set_tx_win_size(UINT16 mtu, UINT16 mps)
220 tx_win_size = (mtu/mps)+1;
224 APPL_TRACE_ERROR("The MPS is zero");
229 #if BTA_HL_DEBUG == TRUE
230 APPL_TRACE_DEBUG("bta_hl_set_tx_win_size win_size=%d mtu=%d mps=%d",
231 tx_win_size, mtu, mps);
236 /*******************************************************************************
238 ** Function bta_hl_set_mps
240 ** Description This function sets the MPS
242 ** Returns UINT16 MPS
244 *******************************************************************************/
245 UINT16 bta_hl_set_mps(UINT16 mtu)
248 if (mtu > BTA_HL_L2C_MPS)
250 mps = BTA_HL_L2C_MPS;
256 #if BTA_HL_DEBUG == TRUE
257 APPL_TRACE_DEBUG("bta_hl_set_mps mps=%d mtu=%d",
264 /*******************************************************************************
266 ** Function bta_hl_clean_mdl_cb
268 ** Description This function clean up the specified MDL control block
272 *******************************************************************************/
273 void bta_hl_clean_mdl_cb(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx)
275 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
276 #if BTA_HL_DEBUG == TRUE
277 APPL_TRACE_DEBUG("bta_hl_clean_mdl_cb app_idx=%d mcl_idx=%d mdl_idx=%d",
278 app_idx, mcl_idx, mdl_idx);
280 utl_freebuf((void **) &p_dcb->p_tx_pkt);
281 utl_freebuf((void **) &p_dcb->p_rx_pkt);
282 utl_freebuf((void **) &p_dcb->p_echo_tx_pkt);
283 utl_freebuf((void **) &p_dcb->p_echo_rx_pkt);
285 memset((void *)p_dcb, 0 , sizeof(tBTA_HL_MDL_CB));
289 /*******************************************************************************
291 ** Function bta_hl_get_buf
293 ** Description This function allocate a buffer based on the specified data size
297 *******************************************************************************/
298 BT_HDR * bta_hl_get_buf(UINT16 data_size)
301 UINT16 size = data_size + L2CAP_MIN_OFFSET + BT_HDR_SIZE;
303 if (size < GKI_MAX_BUF_SIZE)
305 p_new = (BT_HDR *)GKI_getbuf(size);
309 p_new = (BT_HDR *) GKI_getpoolbuf(BTA_HL_LRG_DATA_POOL_ID);
314 p_new->len = data_size;
315 p_new->offset = L2CAP_MIN_OFFSET;
321 /*******************************************************************************
323 ** Function bta_hl_find_service_in_db
325 ** Description This function check the specified service class(es) can be find in
326 ** the received SDP database
328 ** Returns BOOLEAN TRUE - found
331 *******************************************************************************/
332 BOOLEAN bta_hl_find_service_in_db( UINT8 app_idx, UINT8 mcl_idx,
334 tSDP_DISC_REC **pp_rec )
336 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
337 BOOLEAN found = TRUE;
339 switch (service_uuid)
341 case UUID_SERVCLASS_HDP_SINK:
342 case UUID_SERVCLASS_HDP_SOURCE:
343 if ((*pp_rec = SDP_FindServiceInDb(p_mcb->p_db, service_uuid,
350 if (((*pp_rec = bta_hl_find_sink_or_src_srv_class_in_db(p_mcb->p_db,
360 /*******************************************************************************
362 ** Function bta_hl_get_service_uuids
365 ** Description This function finds the service class(es) for both CCH and DCH oeprations
367 ** Returns UINT16 - service_id
368 ** if service_uuid = 0xFFFF then it means service uuid
369 ** can be either Sink or Source
371 *******************************************************************************/
372 UINT16 bta_hl_get_service_uuids(UINT8 sdp_oper, UINT8 app_idx, UINT8 mcl_idx,
375 tBTA_HL_MDL_CB *p_dcb;
376 UINT16 service_uuid = 0xFFFF; /* both Sink and Source */
381 case BTA_HL_SDP_OP_DCH_OPEN_INIT:
382 case BTA_HL_SDP_OP_DCH_RECONNECT_INIT:
383 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
384 if (p_dcb->local_mdep_id != BTA_HL_ECHO_TEST_MDEP_ID)
386 if (p_dcb->peer_mdep_role == BTA_HL_MDEP_ROLE_SINK)
388 service_uuid = UUID_SERVCLASS_HDP_SINK;
392 service_uuid = UUID_SERVCLASS_HDP_SOURCE;
396 case BTA_HL_SDP_OP_CCH_INIT:
398 /* use default that is both Sink and Source */
401 #if BTA_HL_DEBUG == TRUE
402 APPL_TRACE_DEBUG("bta_hl_get_service_uuids service_uuid=0x%x",service_uuid );
407 /*******************************************************************************
409 ** Function bta_hl_find_echo_cfg_rsp
412 ** Description This function finds the configuration response for the echo test
414 ** Returns BOOLEAN - TRUE found
417 *******************************************************************************/
418 BOOLEAN bta_hl_find_echo_cfg_rsp(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdep_idx, UINT8 cfg,
421 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
422 tBTA_HL_MDEP *p_mdep= &p_acb->sup_feature.mdep[mdep_idx];
423 BOOLEAN status =TRUE;
425 if (p_mdep->mdep_id == BTA_HL_ECHO_TEST_MDEP_ID)
427 if ((cfg == BTA_HL_DCH_CFG_RELIABLE) || (cfg == BTA_HL_DCH_CFG_STREAMING))
431 else if (cfg == BTA_HL_DCH_CFG_NO_PREF )
433 *p_cfg_rsp = BTA_HL_DEFAULT_ECHO_TEST_SRC_DCH_CFG;
438 APPL_TRACE_ERROR("Inavlid echo cfg value");
443 #if BTA_HL_DEBUG == TRUE
446 APPL_TRACE_DEBUG("bta_hl_find_echo_cfg_rsp status=failed app_idx=%d mcl_idx=%d mdep_idx=%d cfg=%d",
447 app_idx, mcl_idx, mdep_idx, cfg);
454 /*******************************************************************************
456 ** Function bta_hl_validate_dch_cfg
458 ** Description This function validate the DCH configuration
460 ** Returns BOOLEAN - TRUE cfg is valid
463 *******************************************************************************/
464 BOOLEAN bta_hl_validate_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
467 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
468 BOOLEAN is_valid =FALSE;
471 if (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx) &&
472 (cfg != BTA_HL_DCH_CFG_RELIABLE))
474 APPL_TRACE_ERROR("the first DCH should be a reliable channel");
478 switch (p_dcb->local_cfg)
480 case BTA_HL_DCH_CFG_NO_PREF:
482 if ((cfg == BTA_HL_DCH_CFG_RELIABLE) || (cfg == BTA_HL_DCH_CFG_STREAMING))
487 case BTA_HL_DCH_CFG_RELIABLE:
488 case BTA_HL_DCH_CFG_STREAMING:
489 if (p_dcb->local_cfg == cfg )
498 #if BTA_HL_DEBUG == TRUE
501 APPL_TRACE_DEBUG("bta_hl_validate_dch_open_cfg is_valid=%d, cfg=%d", is_valid, cfg );
507 /*******************************************************************************
509 ** Function bta_hl_find_cch_cb_indexes
511 ** Description This function finds the indexes needed for the CCH state machine
513 ** Returns BOOLEAN - TRUE found
516 *******************************************************************************/
517 BOOLEAN bta_hl_find_cch_cb_indexes(tBTA_HL_DATA *p_msg,
521 BOOLEAN found = FALSE;
522 tBTA_HL_MCL_CB *p_mcb;
523 UINT8 app_idx = 0, mcl_idx = 0;
525 switch (p_msg->hdr.event)
527 case BTA_HL_CCH_SDP_OK_EVT:
528 case BTA_HL_CCH_SDP_FAIL_EVT:
529 app_idx = p_msg->cch_sdp.app_idx;
530 mcl_idx = p_msg->cch_sdp.mcl_idx;
534 case BTA_HL_MCA_CONNECT_IND_EVT:
536 if (bta_hl_find_app_idx_using_handle(p_msg->mca_evt.app_handle, &app_idx))
538 if (bta_hl_find_mcl_idx(app_idx, p_msg->mca_evt.mca_data.connect_ind.bd_addr, &mcl_idx))
540 /* local initiated */
543 else if (!bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx)&&
544 bta_hl_find_avail_mcl_idx(app_idx, &mcl_idx))
546 /* remote initiated */
547 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
548 p_mcb->in_use = TRUE;
549 p_mcb->cch_oper = BTA_HL_CCH_OP_REMOTE_OPEN;
555 case BTA_HL_MCA_DISCONNECT_IND_EVT:
557 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx))
561 else if (bta_hl_find_app_idx_using_handle(p_msg->mca_evt.app_handle, &app_idx) &&
562 bta_hl_find_mcl_idx(app_idx, p_msg->mca_evt.mca_data.disconnect_ind.bd_addr, &mcl_idx))
569 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
570 if ((p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_CLOSE) && (p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_OPEN) )
572 p_mcb->cch_oper = BTA_HL_CCH_OP_REMOTE_CLOSE;
577 case BTA_HL_MCA_RSP_TOUT_IND_EVT:
579 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx))
586 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
587 if ((p_mcb->cch_oper != BTA_HL_CCH_OP_REMOTE_CLOSE) && (p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_OPEN))
589 p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_CLOSE;
600 *p_app_idx = app_idx;
601 *p_mcl_idx = mcl_idx;
604 #if BTA_HL_DEBUG == TRUE
607 APPL_TRACE_DEBUG("bta_hl_find_cch_cb_indexes event=%s found=%d app_idx=%d mcl_idx=%d",
608 bta_hl_evt_code(p_msg->hdr.event), found, app_idx, mcl_idx);
615 /*******************************************************************************
617 ** Function bta_hl_find_dch_cb_indexes
619 ** Description This function finds the indexes needed for the DCH state machine
621 ** Returns BOOLEAN - TRUE found
624 *******************************************************************************/
625 BOOLEAN bta_hl_find_dch_cb_indexes(tBTA_HL_DATA *p_msg,
630 BOOLEAN found = FALSE;
631 tBTA_HL_MCL_CB *p_mcb;
632 UINT8 app_idx = 0, mcl_idx = 0, mdl_idx = 0;
634 switch (p_msg->hdr.event)
636 case BTA_HL_MCA_CREATE_CFM_EVT:
637 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
638 bta_hl_find_mdl_idx( app_idx, mcl_idx, p_msg->mca_evt.mca_data.create_cfm.mdl_id, &mdl_idx))
644 case BTA_HL_MCA_CREATE_IND_EVT:
645 case BTA_HL_MCA_RECONNECT_IND_EVT:
646 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
647 bta_hl_find_avail_mdl_idx( app_idx, mcl_idx, &mdl_idx))
653 case BTA_HL_MCA_OPEN_CFM_EVT:
654 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
655 bta_hl_find_mdl_idx( app_idx, mcl_idx, p_msg->mca_evt.mca_data.open_cfm.mdl_id, &mdl_idx))
661 case BTA_HL_MCA_OPEN_IND_EVT:
662 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
663 bta_hl_find_mdl_idx( app_idx, mcl_idx, p_msg->mca_evt.mca_data.open_ind.mdl_id, &mdl_idx))
669 case BTA_HL_MCA_CLOSE_CFM_EVT:
671 if (bta_hl_find_mdl_idx_using_handle((tBTA_HL_MDL_HANDLE)p_msg->mca_evt.mca_data.close_cfm.mdl,
672 &app_idx, &mcl_idx, &mdl_idx))
677 case BTA_HL_MCA_CLOSE_IND_EVT:
679 if (bta_hl_find_mdl_idx_using_handle((tBTA_HL_MDL_HANDLE)p_msg->mca_evt.mca_data.close_ind.mdl,
680 &app_idx, &mcl_idx, &mdl_idx))
685 case BTA_HL_API_SEND_DATA_EVT:
687 if (bta_hl_find_mdl_idx_using_handle(p_msg->api_send_data.mdl_handle,
688 &app_idx, &mcl_idx, &mdl_idx ))
695 case BTA_HL_MCA_CONG_CHG_EVT:
697 if (bta_hl_find_mdl_idx_using_handle((tBTA_HL_MDL_HANDLE)p_msg->mca_evt.mca_data.cong_chg.mdl,
698 &app_idx, &mcl_idx, &mdl_idx ))
705 case BTA_HL_MCA_RCV_DATA_EVT:
706 app_idx = p_msg->mca_rcv_data_evt.app_idx;
707 mcl_idx = p_msg->mca_rcv_data_evt.mcl_idx;
708 mdl_idx = p_msg->mca_rcv_data_evt.mdl_idx;
711 case BTA_HL_DCH_RECONNECT_EVT:
712 case BTA_HL_DCH_OPEN_EVT:
713 case BTA_HL_DCH_ECHO_TEST_EVT:
714 case BTA_HL_DCH_SDP_FAIL_EVT:
715 app_idx = p_msg->dch_sdp.app_idx;
716 mcl_idx = p_msg->dch_sdp.mcl_idx;
717 mdl_idx = p_msg->dch_sdp.mdl_idx;
720 case BTA_HL_MCA_RECONNECT_CFM_EVT:
721 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
722 bta_hl_find_mdl_idx( app_idx, mcl_idx, p_msg->mca_evt.mca_data.reconnect_cfm.mdl_id, &mdl_idx))
729 case BTA_HL_API_DCH_CREATE_RSP_EVT:
730 if (bta_hl_find_mcl_idx_using_handle(p_msg->api_dch_create_rsp.mcl_handle, &app_idx, &mcl_idx)&&
731 bta_hl_find_mdl_idx( app_idx, mcl_idx,p_msg->api_dch_create_rsp.mdl_id, &mdl_idx))
736 case BTA_HL_MCA_ABORT_IND_EVT:
737 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
738 bta_hl_find_mdl_idx( app_idx, mcl_idx,p_msg->mca_evt.mca_data.abort_ind.mdl_id, &mdl_idx))
743 case BTA_HL_MCA_ABORT_CFM_EVT:
744 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
745 bta_hl_find_mdl_idx( app_idx, mcl_idx, p_msg->mca_evt.mca_data.abort_cfm.mdl_id, &mdl_idx))
750 case BTA_HL_CI_GET_TX_DATA_EVT:
751 case BTA_HL_CI_PUT_RX_DATA_EVT:
752 if (bta_hl_find_mdl_idx_using_handle(p_msg->ci_get_put_data.mdl_handle, &app_idx, &mcl_idx, &mdl_idx))
757 case BTA_HL_CI_GET_ECHO_DATA_EVT:
758 case BTA_HL_CI_PUT_ECHO_DATA_EVT:
759 if (bta_hl_find_mcl_idx_using_handle(p_msg->ci_get_put_echo_data.mcl_handle, &app_idx, &mcl_idx))
761 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
762 mdl_idx = p_mcb->echo_mdl_idx;
774 *p_app_idx = app_idx;
775 *p_mcl_idx = mcl_idx;
776 *p_mdl_idx = mdl_idx;
778 #if BTA_HL_DEBUG == TRUE
781 APPL_TRACE_DEBUG("bta_hl_find_dch_cb_indexes event=%s found=%d app_idx=%d mcl_idx=%d mdl_idx=%d",
782 bta_hl_evt_code(p_msg->hdr.event), found, *p_app_idx, *p_mcl_idx, *p_mdl_idx );
789 /*******************************************************************************
791 ** Function bta_hl_allocate_mdl_id
793 ** Description This function allocates a MDL ID
795 ** Returns UINT16 - MDL ID
797 *******************************************************************************/
798 UINT16 bta_hl_allocate_mdl_id(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx )
801 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
802 BOOLEAN duplicate_id;
803 UINT8 i, mdl_cfg_idx;
807 duplicate_id = FALSE;
808 mdl_id = ((mdl_id+1) & 0xFEFF);
809 /* check mdl_ids that are used for the current conenctions */
810 for (i=0; i< BTA_HL_NUM_MDLS_PER_MCL; i++)
812 if (p_mcb->mdl[i].in_use &&
814 (p_mcb->mdl[i].mdl_id == mdl_id) )
823 /* start from the beginning to get another MDL value*/
828 /* check mdl_ids that are stored in the persistent memory */
829 if (bta_hl_find_mdl_cfg_idx(app_idx,mcl_idx, mdl_id, &mdl_cfg_idx))
835 /* found a new MDL value */
842 #if BTA_HL_DEBUG == TRUE
843 APPL_TRACE_DEBUG("bta_hl_allocate_mdl OK mdl_id=%d", mdl_id);
847 /*******************************************************************************
849 ** Function bta_hl_find_mdl_idx
851 ** Description This function finds the MDL index based on mdl_id
853 ** Returns BOOLEAN TRUE-found
855 *******************************************************************************/
856 BOOLEAN bta_hl_find_mdl_idx(UINT8 app_idx, UINT8 mcl_idx, UINT16 mdl_id,
859 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
863 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
865 if (p_mcb->mdl[i].in_use &&
867 (p_mcb->mdl[i].mdl_id== mdl_id))
875 #if BTA_HL_DEBUG == TRUE
878 APPL_TRACE_DEBUG("bta_hl_find_mdl_idx found=%d mdl_id=%d mdl_idx=%d ",
886 /*******************************************************************************
888 ** Function bta_hl_find_an_active_mdl_idx
890 ** Description This function finds an active MDL
892 ** Returns BOOLEAN TRUE-found
894 *******************************************************************************/
895 BOOLEAN bta_hl_find_an_active_mdl_idx(UINT8 app_idx, UINT8 mcl_idx,
898 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
902 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
904 if (p_mcb->mdl[i].in_use &&
905 (p_mcb->mdl[i].dch_state == BTA_HL_DCH_OPEN_ST))
913 #if BTA_HL_DEBUG == TRUE
916 APPL_TRACE_DEBUG("bta_hl_find_an_opened_mdl_idx found=%d app_idx=%d mcl_idx=%d mdl_idx=%d",
917 found, app_idx, mcl_idx, i);
924 /*******************************************************************************
926 ** Function bta_hl_find_dch_setup_mdl_idx
928 ** Description This function finds a MDL which in the DCH setup state
930 ** Returns BOOLEAN TRUE-found
932 *******************************************************************************/
933 BOOLEAN bta_hl_find_dch_setup_mdl_idx(UINT8 app_idx, UINT8 mcl_idx,
936 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
940 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
942 if (p_mcb->mdl[i].in_use &&
943 (p_mcb->mdl[i].dch_state == BTA_HL_DCH_OPENING_ST))
951 #if BTA_HL_DEBUG == TRUE
954 APPL_TRACE_DEBUG("bta_hl_find_dch_setup_mdl_idx found=%d app_idx=%d mcl_idx=%d mdl_idx=%d",
955 found, app_idx, mcl_idx, i);
962 /*******************************************************************************
964 ** Function bta_hl_find_an_in_use_mcl_idx
966 ** Description This function finds an in-use MCL control block index
968 ** Returns BOOLEAN TRUE-found
970 *******************************************************************************/
971 BOOLEAN bta_hl_find_an_in_use_mcl_idx(UINT8 app_idx,
974 tBTA_HL_MCL_CB *p_mcb;
978 for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
980 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, i);
982 (p_mcb->cch_state != BTA_HL_CCH_IDLE_ST))
990 #if BTA_HL_DEBUG == TRUE
993 APPL_TRACE_DEBUG("bta_hl_find_an_in_use_mcl_idx found=%d app_idx=%d mcl_idx=%d ",
1002 /*******************************************************************************
1004 ** Function bta_hl_find_an_in_use_app_idx
1006 ** Description This function finds an in-use application control block index
1008 ** Returns BOOLEAN TRUE-found
1010 *******************************************************************************/
1011 BOOLEAN bta_hl_find_an_in_use_app_idx(UINT8 *p_app_idx)
1013 tBTA_HL_APP_CB *p_acb ;
1014 BOOLEAN found=FALSE;
1017 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1019 p_acb = BTA_HL_GET_APP_CB_PTR(i);
1028 #if BTA_HL_DEBUG == TRUE
1031 APPL_TRACE_DEBUG("bta_hl_find_an_in_use_app_idx found=%d app_idx=%d ",
1038 /*******************************************************************************
1040 ** Function bta_hl_find_app_idx
1042 ** Description This function finds the application control block index based on
1043 ** the application ID
1045 ** Returns BOOLEAN TRUE-found
1047 *******************************************************************************/
1048 BOOLEAN bta_hl_find_app_idx(UINT8 app_id, UINT8 *p_app_idx)
1050 BOOLEAN found=FALSE;
1053 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1055 if (bta_hl_cb.acb[i].in_use &&
1056 (bta_hl_cb.acb[i].app_id == app_id))
1064 #if BTA_HL_DEBUG == TRUE
1065 APPL_TRACE_DEBUG("bta_hl_find_app_idx found=%d app_id=%d idx=%d ",
1073 /*******************************************************************************
1075 ** Function bta_hl_find_app_idx_using_handle
1077 ** Description This function finds the application control block index based on
1078 ** the application handle
1080 ** Returns BOOLEAN TRUE-found
1082 *******************************************************************************/
1083 BOOLEAN bta_hl_find_app_idx_using_handle(tBTA_HL_APP_HANDLE app_handle,
1086 BOOLEAN found=FALSE;
1089 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1091 if (bta_hl_cb.acb[i].in_use &&
1092 (bta_hl_cb.acb[i].app_handle == app_handle))
1100 #if BTA_HL_DEBUG == TRUE
1103 APPL_TRACE_DEBUG("bta_hl_find_app_idx_using_mca_handle status=%d handle=%d app_idx=%d ",
1104 found, app_handle , i);
1112 /*******************************************************************************
1114 ** Function bta_hl_find_mcl_idx_using_handle
1116 ** Description This function finds the MCL control block index based on
1119 ** Returns BOOLEAN TRUE-found
1121 *******************************************************************************/
1122 BOOLEAN bta_hl_find_mcl_idx_using_handle( tBTA_HL_MCL_HANDLE mcl_handle,
1123 UINT8 *p_app_idx, UINT8 *p_mcl_idx)
1125 tBTA_HL_APP_CB *p_acb;
1126 BOOLEAN found=FALSE;
1129 for (i=0; i<BTA_HL_NUM_APPS; i++)
1131 p_acb = BTA_HL_GET_APP_CB_PTR(i);
1134 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
1136 if ( p_acb->mcb[j].mcl_handle == mcl_handle )
1147 #if BTA_HL_DEBUG == TRUE
1150 APPL_TRACE_DEBUG("bta_hl_find_mcl_idx_using_handle found=%d app_idx=%d mcl_idx=%d",
1157 /*******************************************************************************
1159 ** Function bta_hl_find_mcl_idx
1161 ** Description This function finds the MCL control block index based on
1162 ** the peer BD address
1164 ** Returns BOOLEAN TRUE-found
1166 *******************************************************************************/
1167 BOOLEAN bta_hl_find_mcl_idx(UINT8 app_idx, BD_ADDR p_bd_addr, UINT8 *p_mcl_idx)
1169 BOOLEAN found=FALSE;
1171 tBTA_HL_MCL_CB *p_mcb;
1173 for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
1175 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, i);
1177 if (bta_hl_cb.acb[app_idx].mcb[i].in_use &&
1178 (!memcmp (bta_hl_cb.acb[app_idx].mcb[i].bd_addr, p_bd_addr, BD_ADDR_LEN)))
1186 #if BTA_HL_DEBUG == TRUE
1189 APPL_TRACE_DEBUG("bta_hl_find_mcl_idx found=%d idx=%d",
1198 /*******************************************************************************
1200 ** Function bta_hl_find_mdl_idx_using_handle
1202 ** Description This function finds the MDL control block index based on
1205 ** Returns BOOLEAN TRUE-found
1207 *******************************************************************************/
1208 BOOLEAN bta_hl_find_mdl_idx_using_handle(tBTA_HL_MDL_HANDLE mdl_handle,
1209 UINT8 *p_app_idx,UINT8 *p_mcl_idx,
1212 tBTA_HL_APP_CB *p_acb;
1213 tBTA_HL_MCL_CB *p_mcb;
1214 tBTA_HL_MDL_CB *p_dcb;
1215 BOOLEAN found=FALSE;
1218 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1220 p_acb = BTA_HL_GET_APP_CB_PTR(i);
1223 for (j=0; j< BTA_HL_NUM_MCLS; j++)
1225 p_mcb = BTA_HL_GET_MCL_CB_PTR(i,j);
1228 for (k=0; k< BTA_HL_NUM_MDLS_PER_MCL; k++)
1230 p_dcb = BTA_HL_GET_MDL_CB_PTR(i,j,k);
1233 if (p_dcb->mdl_handle == mdl_handle)
1249 #if BTA_HL_DEBUG == TRUE
1252 APPL_TRACE_DEBUG("bta_hl_find_mdl_idx_using_handle found=%d mdl_handle=%d ",
1258 /*******************************************************************************
1260 ** Function bta_hl_is_the_first_reliable_existed
1262 ** Description This function checks whether the first reliable DCH channel
1263 ** has been setup on the MCL or not
1265 ** Returns BOOLEAN - TRUE exist
1266 ** FALSE does not exist
1268 *******************************************************************************/
1269 BOOLEAN bta_hl_is_the_first_reliable_existed(UINT8 app_idx, UINT8 mcl_idx )
1271 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1272 BOOLEAN is_existed =FALSE;
1275 for (i=0; i< BTA_HL_NUM_MDLS_PER_MCL; i++)
1277 if (p_mcb->mdl[i].in_use && p_mcb->mdl[i].is_the_first_reliable)
1284 #if BTA_HL_DEBUG == TRUE
1285 APPL_TRACE_DEBUG("bta_hl_is_the_first_reliable_existed is_existed=%d ",is_existed );
1290 /*******************************************************************************
1292 ** Function bta_hl_find_non_active_mdl_cfg
1294 ** Description This function finds a valid MDL configiration index and this
1295 ** MDL ID is not active
1297 ** Returns BOOLEAN - TRUE found
1300 *******************************************************************************/
1301 BOOLEAN bta_hl_find_non_active_mdl_cfg(UINT8 app_idx, UINT8 start_mdl_cfg_idx,
1302 UINT8 *p_mdl_cfg_idx)
1305 tBTA_HL_MCL_CB *p_mcb;
1306 tBTA_HL_MDL_CB *p_dcb;
1307 tBTA_HL_MDL_CFG *p_mdl;
1309 BOOLEAN found = FALSE;
1312 for (i = start_mdl_cfg_idx; i< BTA_HL_NUM_MDL_CFGS; i++)
1315 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1316 for (j=0; j< BTA_HL_NUM_MCLS; j++)
1318 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, j);
1319 if (p_mcb->in_use &&
1320 !memcmp(p_mdl->peer_bd_addr,p_mcb->bd_addr,BD_ADDR_LEN))
1323 for (k=0; k<BTA_HL_NUM_MDLS_PER_MCL; k++)
1325 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, j, k);
1327 if (p_dcb->in_use && p_mdl->mdl_id == p_dcb->mdl_id)
1352 /*******************************************************************************
1354 ** Function bta_hl_find_mdl_cfg_idx
1356 ** Description This function finds an available MDL configuration index
1358 ** Returns BOOLEAN - TRUE found
1361 *******************************************************************************/
1362 BOOLEAN bta_hl_find_avail_mdl_cfg_idx(UINT8 app_idx, UINT8 mcl_idx,
1363 UINT8 *p_mdl_cfg_idx)
1365 tBTA_HL_MDL_CFG *p_mdl, *p_mdl1, *p_mdl2;
1367 BOOLEAN found=FALSE;
1368 UINT8 first_mdl_cfg_idx, second_mdl_cfg_idx, older_mdl_cfg_idx;
1372 for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1374 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1375 if (!p_mdl->active )
1377 /* found an unused space to store mdl cfg*/
1386 /* all available mdl cfg spaces are in use so we need to find the mdl cfg which is
1387 not currently in use and has the the oldest time stamp to remove*/
1390 if (bta_hl_find_non_active_mdl_cfg(app_idx,0, &first_mdl_cfg_idx))
1392 if (bta_hl_find_non_active_mdl_cfg(app_idx,(UINT8) (first_mdl_cfg_idx+1), &second_mdl_cfg_idx))
1397 p_mdl1 = BTA_HL_GET_MDL_CFG_PTR(app_idx, first_mdl_cfg_idx);
1398 p_mdl2 = BTA_HL_GET_MDL_CFG_PTR(app_idx, second_mdl_cfg_idx);
1400 if (p_mdl1->time < p_mdl2->time)
1402 older_mdl_cfg_idx = first_mdl_cfg_idx;
1406 older_mdl_cfg_idx = second_mdl_cfg_idx;
1409 if (bta_hl_find_non_active_mdl_cfg(app_idx,(UINT8) (second_mdl_cfg_idx+1), &second_mdl_cfg_idx))
1411 first_mdl_cfg_idx = older_mdl_cfg_idx;
1419 *p_mdl_cfg_idx = older_mdl_cfg_idx;
1424 *p_mdl_cfg_idx = first_mdl_cfg_idx;
1434 #if BTA_HL_DEBUG == TRUE
1437 APPL_TRACE_DEBUG("bta_hl_find_avail_mdl_cfg_idx found=%d mdl_cfg_idx=%d ",found, *p_mdl_cfg_idx );
1446 /*******************************************************************************
1448 ** Function bta_hl_find_mdl_cfg_idx
1450 ** Description This function finds the MDL configuration index based on
1453 ** Returns BOOLEAN - TRUE found
1456 *******************************************************************************/
1457 BOOLEAN bta_hl_find_mdl_cfg_idx(UINT8 app_idx, UINT8 mcl_idx,
1458 tBTA_HL_MDL_ID mdl_id, UINT8 *p_mdl_cfg_idx)
1460 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1461 tBTA_HL_MDL_CFG *p_mdl;
1463 BOOLEAN found=FALSE;
1466 for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1468 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1470 APPL_TRACE_DEBUG("bta_hl_find_mdl_cfg_idx: mdl_id =%d, p_mdl->mdl_id=%d",mdl_id,
1472 if (p_mdl->active &&
1473 (!memcmp (p_mcb->bd_addr, p_mdl->peer_bd_addr, BD_ADDR_LEN))&&
1474 (p_mdl->mdl_id == mdl_id))
1482 #if BTA_HL_DEBUG == TRUE
1485 APPL_TRACE_DEBUG("bta_hl_find_mdl_cfg_idx found=%d mdl_cfg_idx=%d ",found, i );
1495 /*******************************************************************************
1497 ** Function bta_hl_get_cur_time
1499 ** Description This function get the cuurent time value
1501 ** Returns BOOLEAN - TRUE found
1504 *******************************************************************************/
1505 BOOLEAN bta_hl_get_cur_time(UINT8 app_idx, UINT8 *p_cur_time)
1507 tBTA_HL_MDL_CFG *p_mdl;
1508 UINT8 i, j, time_latest, time;
1509 BOOLEAN found=FALSE, result=TRUE;
1511 for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1513 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1517 time_latest = p_mdl->time;
1518 for (j=(i+1); j< BTA_HL_NUM_MDL_CFGS; j++ )
1520 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, j);
1524 if (time > time_latest)
1537 if (time_latest < BTA_HL_MAX_TIME)
1539 *p_cur_time = time_latest+1;
1543 /* need to wrap around */
1549 *p_cur_time = BTA_HL_MIN_TIME;
1552 #if BTA_HL_DEBUG == TRUE
1555 APPL_TRACE_DEBUG("bta_hl_get_cur_time result=%s cur_time=%d",
1556 (result?"OK":"FAIL"), *p_cur_time);
1563 /*******************************************************************************
1565 ** Function bta_hl_sort_cfg_time_idx
1567 ** Description This function sort the mdl configuration idx stored in array a
1568 ** based on decending time value
1570 ** Returns BOOLEAN - TRUE found
1573 *******************************************************************************/
1574 void bta_hl_sort_cfg_time_idx(UINT8 app_idx, UINT8 *a, UINT8 n)
1576 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1577 UINT8 temp_time, temp_idx;
1579 for (i = 1; i < n; ++i)
1582 temp_time = p_acb->mdl_cfg[temp_idx].time;
1584 while ((j >= 0) && (temp_time < p_acb->mdl_cfg[a[j]].time))
1589 a[j + 1] = temp_idx;
1593 /*******************************************************************************
1595 ** Function bta_hl_compact_mdl_cfg_time
1597 ** Description This function finds the MDL configuration index based on
1600 ** Returns BOOLEAN - TRUE found
1603 *******************************************************************************/
1604 void bta_hl_compact_mdl_cfg_time(UINT8 app_idx, UINT8 mdep_id)
1606 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1607 tBTA_HL_MDL_CFG *p_mdl;
1608 UINT8 i, time_min, cnt=0;
1609 UINT8 s_arr[BTA_HL_NUM_MDL_CFGS];
1612 for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1614 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1624 #if BTA_HL_DEBUG == TRUE
1625 APPL_TRACE_DEBUG("bta_hl_compact_mdl_cfg_time cnt=%d ",cnt );
1631 bta_hl_sort_cfg_time_idx(app_idx, s_arr, cnt);
1632 time_min = BTA_HL_MIN_TIME;
1633 for (i=0;i<cnt; i++)
1635 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, s_arr[i]);
1636 p_mdl->time = time_min + i;
1637 bta_hl_co_save_mdl(mdep_id, s_arr[i], p_mdl);
1646 /*******************************************************************************
1648 ** Function bta_hl_is_mdl_exsit_in_mcl
1650 ** Description This function checks whether the MDL ID
1651 ** has already existed in teh MCL or not
1653 ** Returns BOOLEAN - TRUE exist
1654 ** FALSE does not exist
1656 *******************************************************************************/
1657 BOOLEAN bta_hl_is_mdl_exsit_in_mcl(UINT8 app_idx, BD_ADDR bd_addr,
1658 tBTA_HL_MDL_ID mdl_id)
1660 tBTA_HL_MDL_CFG *p_mdl;
1661 BOOLEAN found = FALSE;
1664 for (i = 0; i< BTA_HL_NUM_MDL_CFGS; i++)
1666 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1667 if (p_mdl->active &&
1668 !memcmp(p_mdl->peer_bd_addr, bd_addr,BD_ADDR_LEN))
1670 if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS)
1672 if (p_mdl->mdl_id == mdl_id)
1689 /*******************************************************************************
1691 ** Function bta_hl_delete_mdl_cfg
1693 ** Description This function delete the specified MDL ID
1695 ** Returns BOOLEAN - TRUE Success
1698 *******************************************************************************/
1699 BOOLEAN bta_hl_delete_mdl_cfg(UINT8 app_idx, BD_ADDR bd_addr,
1700 tBTA_HL_MDL_ID mdl_id)
1702 tBTA_HL_MDL_CFG *p_mdl;
1703 BOOLEAN success = FALSE;
1705 tBTA_HL_APP_CB *p_acb= BTA_HL_GET_APP_CB_PTR(app_idx);
1706 UINT8 app_id = p_acb->app_id;
1708 for (i = 0; i< BTA_HL_NUM_MDL_CFGS; i++)
1710 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1711 if (p_mdl->active &&
1712 !memcmp(p_mdl->peer_bd_addr, bd_addr,BD_ADDR_LEN))
1714 if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS)
1716 if (p_mdl->mdl_id == mdl_id)
1718 bta_hl_co_delete_mdl(p_mdl->local_mdep_id, i);
1719 memset(p_mdl, 0, sizeof(tBTA_HL_MDL_CFG));
1726 bta_hl_co_delete_mdl(p_mdl->local_mdep_id, i);
1727 memset(p_mdl, 0, sizeof(tBTA_HL_MDL_CFG));
1737 /*******************************************************************************
1739 ** Function bta_hl_is_mdl_value_valid
1742 ** Description This function checks the specified MDL ID is in valid range or not
1744 ** Returns BOOLEAN - TRUE Success
1747 ** note: mdl_id range 0x0000 reserved,
1748 ** 0x0001-oxFEFF dynamic range,
1749 ** 0xFF00-0xFFFE reserved,
1750 ** 0xFFFF indicates all MDLs (for delete operation only)
1752 *******************************************************************************/
1753 BOOLEAN bta_hl_is_mdl_value_valid(tBTA_HL_MDL_ID mdl_id)
1755 BOOLEAN status = TRUE;
1757 if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS)
1761 if (mdl_id > BTA_HL_MAX_MDL_VAL )
1775 /*******************************************************************************
1777 ** Function bta_hl_find_mdep_cfg_idx
1779 ** Description This function finds the MDEP configuration index based
1780 ** on the local MDEP ID
1782 ** Returns BOOLEAN - TRUE found
1785 *******************************************************************************/
1786 BOOLEAN bta_hl_find_mdep_cfg_idx(UINT8 app_idx, tBTA_HL_MDEP_ID local_mdep_id,
1787 UINT8 *p_mdep_cfg_idx)
1789 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1790 tBTA_HL_SUP_FEATURE *p_sup_feature= &p_acb->sup_feature;
1791 BOOLEAN found =FALSE;
1794 for (i=0; i< p_sup_feature->num_of_mdeps; i++)
1796 if ( p_sup_feature->mdep[i].mdep_id == local_mdep_id)
1799 *p_mdep_cfg_idx = i;
1804 #if BTA_HL_DEBUG == TRUE
1807 APPL_TRACE_DEBUG("bta_hl_find_mdep_cfg_idx found=%d mdep_idx=%d local_mdep_id=%d ",
1808 found,i, local_mdep_id );
1815 /*******************************************************************************
1817 ** Function bta_hl_find_rxtx_apdu_size
1819 ** Description This function finds the maximum APDU rx and tx sizes based on
1820 ** the MDEP configuration data
1824 *******************************************************************************/
1825 void bta_hl_find_rxtx_apdu_size(UINT8 app_idx, UINT8 mdep_cfg_idx,
1826 UINT16 *p_rx_apu_size,
1827 UINT16 *p_tx_apu_size)
1829 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1830 tBTA_HL_MDEP_CFG *p_mdep_cfg;
1832 UINT16 max_rx_apdu_size=0, max_tx_apdu_size=0;
1834 p_mdep_cfg = &p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg;
1837 for (i=0; i< p_mdep_cfg->num_of_mdep_data_types ; i++)
1840 if (max_rx_apdu_size < p_mdep_cfg->data_cfg[i].max_rx_apdu_size)
1842 max_rx_apdu_size = p_mdep_cfg->data_cfg[i].max_rx_apdu_size;
1845 if (max_tx_apdu_size < p_mdep_cfg->data_cfg[i].max_tx_apdu_size)
1847 max_tx_apdu_size = p_mdep_cfg->data_cfg[i].max_tx_apdu_size;
1852 *p_rx_apu_size = max_rx_apdu_size;
1853 *p_tx_apu_size = max_tx_apdu_size;
1855 #if BTA_HL_DEBUG == TRUE
1856 APPL_TRACE_DEBUG("bta_hl_find_rxtx_apdu_size max_rx_apdu_size=%d max_tx_apdu_size=%d ",
1857 max_rx_apdu_size, max_tx_apdu_size );
1863 /*******************************************************************************
1865 ** Function bta_hl_validate_peer_cfg
1867 ** Description This function validates the peer DCH configuration
1869 ** Returns BOOLEAN - TRUE validation is successful
1870 ** FALSE validation failed
1872 *******************************************************************************/
1873 BOOLEAN bta_hl_validate_peer_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
1874 tBTA_HL_MDEP_ID peer_mdep_id,
1875 tBTA_HL_MDEP_ROLE peer_mdep_role,
1878 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1879 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1880 tBTA_HL_SDP_REC *p_rec;
1881 BOOLEAN peer_found =FALSE;
1884 APPL_TRACE_DEBUG("bta_hl_validate_peer_cfg sdp_idx=%d app_idx %d", sdp_idx, app_idx);
1887 if (p_dcb->local_mdep_id == BTA_HL_ECHO_TEST_MDEP_ID)
1892 p_rec = &p_mcb->sdp.sdp_rec[sdp_idx];
1893 for (i=0; i< p_rec->num_mdeps; i++)
1895 APPL_TRACE_DEBUG("mdep_id %d peer_mdep_id %d",p_rec->mdep_cfg[i].mdep_id , peer_mdep_id);
1896 APPL_TRACE_DEBUG("mdep_role %d peer_mdep_role %d",p_rec->mdep_cfg[i].mdep_role,
1898 if ( (p_rec->mdep_cfg[i].mdep_id == peer_mdep_id) &&
1899 (p_rec->mdep_cfg[i].mdep_role == peer_mdep_role))
1907 #if BTA_HL_DEBUG == TRUE
1910 APPL_TRACE_DEBUG("bta_hl_validate_peer_cfg failed num_mdeps=%d",p_rec->num_mdeps);
1916 /*******************************************************************************
1918 ** Function bta_hl_chk_local_cfg
1920 ** Description This function check whether the local DCH configuration is OK or not
1922 ** Returns tBTA_HL_STATUS - OK - local DCH configuration is OK
1923 ** NO_FIRST_RELIABLE - the streaming DCH configuration
1924 ** is not OK and it needs to use
1925 ** reliable DCH configuration
1927 *******************************************************************************/
1928 tBTA_HL_STATUS bta_hl_chk_local_cfg(UINT8 app_idx, UINT8 mcl_idx,
1930 tBTA_HL_DCH_CFG local_cfg)
1932 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1933 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
1935 if ( mdep_cfg_idx &&
1936 (p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SOURCE) &&
1937 (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx)) &&
1938 (local_cfg != BTA_HL_DCH_CFG_RELIABLE))
1940 status = BTA_HL_STATUS_NO_FIRST_RELIABLE;
1941 APPL_TRACE_ERROR("BTA_HL_STATUS_INVALID_DCH_CFG");
1948 /*******************************************************************************
1950 ** Function bta_hl_validate_reconnect_params
1952 ** Description This function validates the reconnect parameters
1954 ** Returns BOOLEAN - TRUE validation is successful
1955 ** FALSE validation failed
1956 *******************************************************************************/
1957 BOOLEAN bta_hl_validate_reconnect_params(UINT8 app_idx, UINT8 mcl_idx,
1958 tBTA_HL_API_DCH_RECONNECT *p_reconnect,
1959 UINT8 *p_mdep_cfg_idx, UINT8 *p_mdl_cfg_idx)
1961 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1962 tBTA_HL_SUP_FEATURE *p_sup_feature = &p_acb->sup_feature;
1965 BOOLEAN local_mdep_id_found =FALSE;
1966 BOOLEAN mdl_cfg_found =FALSE;
1967 BOOLEAN status=FALSE;
1968 UINT8 i, in_use_mdl_idx = 0;
1970 #if BTA_HL_DEBUG == TRUE
1971 APPL_TRACE_DEBUG("bta_hl_validate_reconnect_params mdl_id=%d app_idx=%d", p_reconnect->mdl_id, app_idx);
1973 if (bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, p_reconnect->mdl_id, &mdl_cfg_idx))
1975 mdl_cfg_found = TRUE;
1978 #if BTA_HL_DEBUG == TRUE
1981 APPL_TRACE_DEBUG("mdl_cfg_found not found");
1988 num_mdeps = p_sup_feature->num_of_mdeps;
1989 for (i=0; i< num_mdeps ; i++)
1991 if ( p_sup_feature->mdep[i].mdep_id == p_acb->mdl_cfg[mdl_cfg_idx].local_mdep_id)
1993 local_mdep_id_found = TRUE;
1995 *p_mdl_cfg_idx = mdl_cfg_idx;
2001 #if BTA_HL_DEBUG == TRUE
2002 if (!local_mdep_id_found)
2004 APPL_TRACE_DEBUG("local_mdep_id not found");
2009 if (local_mdep_id_found)
2011 if (!bta_hl_find_mdl_idx(app_idx,mcl_idx, p_reconnect->mdl_id, &in_use_mdl_idx))
2017 APPL_TRACE_ERROR("mdl_id=%d is curreltly in use",p_reconnect->mdl_id);
2021 #if BTA_HL_DEBUG == TRUE
2024 APPL_TRACE_DEBUG("Reconnect validation failed local_mdep_id found=%d mdl_cfg_idx found=%d in_use_mdl_idx=%d ",
2025 local_mdep_id_found, mdl_cfg_found, in_use_mdl_idx);
2031 /*******************************************************************************
2033 ** Function bta_hl_find_avail_mcl_idx
2035 ** Returns BOOLEAN - TRUE found
2038 *******************************************************************************/
2039 BOOLEAN bta_hl_find_avail_mcl_idx(UINT8 app_idx, UINT8 *p_mcl_idx)
2041 BOOLEAN found=FALSE;
2044 for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
2046 if (!bta_hl_cb.acb[app_idx].mcb[i].in_use)
2054 #if BTA_HL_DEBUG == TRUE
2057 APPL_TRACE_DEBUG("bta_hl_find_avail_mcl_idx found=%d idx=%d",
2066 /*******************************************************************************
2068 ** Function bta_hl_find_avail_mdl_idx
2070 ** Description This function finds an available MDL control block index
2072 ** Returns BOOLEAN - TRUE found
2075 *******************************************************************************/
2076 BOOLEAN bta_hl_find_avail_mdl_idx(UINT8 app_idx, UINT8 mcl_idx,
2079 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2080 BOOLEAN found=FALSE;
2083 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
2085 if (!p_mcb->mdl[i].in_use)
2087 memset((void *)&p_mcb->mdl[i],0, sizeof(tBTA_HL_MDL_CB));
2094 #if BTA_HL_DEBUG == TRUE
2097 APPL_TRACE_DEBUG("bta_hl_find_avail_mdl_idx found=%d idx=%d",
2104 /*******************************************************************************
2106 ** Function bta_hl_is_a_duplicate_id
2108 ** Description This function finds the application has been used or not
2110 ** Returns BOOLEAN - TRUE the app_id is a duplicate ID
2111 ** FALSE not a duplicate ID
2112 *******************************************************************************/
2113 BOOLEAN bta_hl_is_a_duplicate_id(UINT8 app_id)
2115 BOOLEAN is_duplicate=FALSE;
2118 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
2120 if (bta_hl_cb.acb[i].in_use &&
2121 (bta_hl_cb.acb[i].app_id == app_id))
2123 is_duplicate = TRUE;
2129 #if BTA_HL_DEBUG == TRUE
2133 APPL_TRACE_DEBUG("bta_hl_is_a_duplicate_id app_id=%d is_duplicate=%d",
2134 app_id, is_duplicate);
2138 return is_duplicate;
2142 /*******************************************************************************
2144 ** Function bta_hl_find_avail_app_idx
2146 ** Description This function finds an available application control block index
2148 ** Returns BOOLEAN - TRUE found
2151 *******************************************************************************/
2152 BOOLEAN bta_hl_find_avail_app_idx(UINT8 *p_idx)
2154 BOOLEAN found=FALSE;
2157 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
2159 if (!bta_hl_cb.acb[i].in_use)
2167 #if BTA_HL_DEBUG == TRUE
2170 APPL_TRACE_DEBUG("bta_hl_find_avail_app_idx found=%d app_idx=%d",
2177 /*******************************************************************************
2179 ** Function bta_hl_app_update
2181 ** Description This function registers an HDP application MCAP and DP
2183 ** Returns tBTA_HL_STATUS -registration status
2185 *******************************************************************************/
2186 tBTA_HL_STATUS bta_hl_app_update(UINT8 app_id, BOOLEAN is_register)
2188 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
2189 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(0);
2191 UINT8 i, mdep_idx, num_of_mdeps;
2192 UINT8 mdep_counter = 0;
2195 #if BTA_HL_DEBUG == TRUE
2196 APPL_TRACE_DEBUG("bta_hl_app_update app_id=%d", app_id);
2201 if ((status == BTA_HL_STATUS_OK) &&
2202 bta_hl_co_get_num_of_mdep(app_id, &num_of_mdeps))
2204 for (i=0; i < num_of_mdeps; i++)
2206 mca_cs.type = MCA_TDEP_DATA;
2207 mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
2208 mca_cs.p_data_cback = bta_hl_mcap_data_cback;
2209 /* Find the first available mdep index, and create a MDL Endpoint */
2210 // make a function later if needed
2211 for (mdep_idx = 1; mdep_idx < BTA_HL_NUM_MDEPS; mdep_idx++)
2213 if ( p_acb->sup_feature.mdep[mdep_idx].mdep_id == 0)
2215 break; /* We found an available index */
2222 /* If no available MDEPs, return error */
2223 if (mdep_idx == BTA_HL_NUM_MDEPS)
2225 APPL_TRACE_ERROR("bta_hl_app_update: Out of MDEP IDs");
2226 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2229 if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
2230 &(p_acb->sup_feature.mdep[mdep_idx].mdep_id), &mca_cs) == MCA_SUCCESS)
2232 if (bta_hl_co_get_mdep_config(app_id,
2235 p_acb->sup_feature.mdep[mdep_idx].mdep_id,
2236 &p_acb->sup_feature.mdep[mdep_idx].mdep_cfg))
2238 p_acb->sup_feature.mdep[mdep_idx].ori_app_id = app_id;
2239 APPL_TRACE_DEBUG("mdep idx %d id %d ori_app_id %d num data type %d",mdep_idx,
2240 p_acb->sup_feature.mdep[mdep_idx].mdep_id,
2241 p_acb->sup_feature.mdep[mdep_idx].ori_app_id,
2242 p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.num_of_mdep_data_types);
2243 if (p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.mdep_role ==
2244 BTA_HL_MDEP_ROLE_SOURCE)
2246 p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SOURCE;
2248 else if (p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.mdep_role ==
2249 BTA_HL_MDEP_ROLE_SINK)
2251 p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SINK;
2255 APPL_TRACE_ERROR("bta_hl_app_registration: Invalid Role %d",
2256 p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.mdep_role);
2257 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2263 APPL_TRACE_ERROR("bta_hl_app_registration: Cfg callout failed");
2264 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2270 APPL_TRACE_ERROR("bta_hl_app_registration: MCA_CreateDep failed");
2271 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2276 p_acb->sup_feature.num_of_mdeps += num_of_mdeps;
2277 APPL_TRACE_DEBUG("num_of_mdeps %d", p_acb->sup_feature.num_of_mdeps);
2279 if ((status == BTA_HL_STATUS_OK) &&
2280 (p_acb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SOURCE))
2282 p_acb->sup_feature.advertize_source_sdp =
2283 bta_hl_co_advrtise_source_sdp(app_id);
2286 if ((status == BTA_HL_STATUS_OK)&&
2287 (!bta_hl_co_get_echo_config(app_id, &p_acb->sup_feature.echo_cfg)))
2289 status = BTA_HL_STATUS_ECHO_CO_FAIL;
2292 if ((status == BTA_HL_STATUS_OK)&&
2293 (!bta_hl_co_load_mdl_config(app_id, BTA_HL_NUM_MDL_CFGS, &p_acb->mdl_cfg[0])))
2295 status = BTA_HL_STATUS_MDL_CFG_CO_FAIL;
2300 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2305 for (i=1; i<BTA_HL_NUM_MDEPS; i++)
2307 if (p_acb->sup_feature.mdep[i].ori_app_id == app_id)
2309 APPL_TRACE_DEBUG("Found index %", i);
2312 if (MCA_DeleteDep((tMCA_HANDLE)p_acb->app_handle,
2313 (p_acb->sup_feature.mdep[i].mdep_id)) != MCA_SUCCESS)
2315 APPL_TRACE_ERROR("Error deregistering");
2316 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2319 memset(&p_acb->sup_feature.mdep[i], 0, sizeof(tBTA_HL_MDEP));
2326 if (status == BTA_HL_STATUS_OK)
2328 /* Register/Update MDEP(s) in SDP Record */
2329 status = bta_hl_sdp_update(app_id);
2331 /* else do cleanup */
2338 /*******************************************************************************
2340 ** Function bta_hl_app_registration
2342 ** Description This function registers an HDP application MCAP and DP
2344 ** Returns tBTA_HL_STATUS -registration status
2346 *******************************************************************************/
2347 tBTA_HL_STATUS bta_hl_app_registration(UINT8 app_idx)
2349 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
2350 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2353 UINT8 i, num_of_mdeps;
2354 UINT8 mdep_counter = 0;
2356 #if BTA_HL_DEBUG == TRUE
2357 APPL_TRACE_DEBUG("bta_hl_app_registration app_idx=%d", app_idx);
2360 reg.ctrl_psm = p_acb->ctrl_psm;
2361 reg.data_psm = p_acb->data_psm;
2362 reg.sec_mask = p_acb->sec_mask;
2363 reg.rsp_tout = BTA_HL_MCAP_RSP_TOUT;
2365 if ( (p_acb->app_handle = (tBTA_HL_APP_HANDLE) MCA_Register(®, bta_hl_mcap_ctrl_cback))!=0)
2367 mca_cs.type = MCA_TDEP_ECHO;
2368 mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
2369 mca_cs.p_data_cback = bta_hl_mcap_data_cback;
2371 if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
2372 &(p_acb->sup_feature.mdep[0].mdep_id),
2373 &mca_cs) == MCA_SUCCESS)
2375 if (p_acb->sup_feature.mdep[0].mdep_id != BTA_HL_ECHO_TEST_MDEP_ID)
2377 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2378 APPL_TRACE_ERROR("BAD MDEP ID for echo test mdep_id=%d",
2379 p_acb->sup_feature.mdep[0].mdep_id );
2384 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2385 APPL_TRACE_ERROR("MCA_CreateDep for echo test(mdep_id=0) failed");
2389 if ((status == BTA_HL_STATUS_OK) &&
2390 bta_hl_co_get_num_of_mdep(p_acb->app_id, &num_of_mdeps))
2392 p_acb->sup_feature.num_of_mdeps = num_of_mdeps+1;
2394 for (i=1; i<p_acb->sup_feature.num_of_mdeps; i++)
2396 mca_cs.type = MCA_TDEP_DATA;
2397 mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
2398 mca_cs.p_data_cback = bta_hl_mcap_data_cback;
2400 if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
2401 &(p_acb->sup_feature.mdep[i].mdep_id), &mca_cs) == MCA_SUCCESS)
2403 if (bta_hl_co_get_mdep_config(p_acb->app_id,
2405 p_acb->sup_feature.mdep[i].mdep_id,
2406 &p_acb->sup_feature.mdep[i].mdep_cfg))
2408 if (p_acb->sup_feature.mdep[i].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
2410 p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SOURCE;
2412 else if (p_acb->sup_feature.mdep[i].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SINK)
2414 p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SINK;
2418 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2421 p_acb->sup_feature.mdep[i].ori_app_id = p_acb->app_id;
2422 APPL_TRACE_DEBUG("index %d ori_app_id %d", i,
2423 p_acb->sup_feature.mdep[i].ori_app_id);
2427 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2433 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2440 if ((status == BTA_HL_STATUS_OK) &&
2441 (p_acb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SOURCE))
2443 /* this is a source only applciation */
2444 p_acb->sup_feature.advertize_source_sdp =
2445 bta_hl_co_advrtise_source_sdp(p_acb->app_id);
2448 if ((status == BTA_HL_STATUS_OK)&&
2449 (!bta_hl_co_get_echo_config(p_acb->app_id, &p_acb->sup_feature.echo_cfg)))
2451 status = BTA_HL_STATUS_ECHO_CO_FAIL;
2454 if ((status == BTA_HL_STATUS_OK)&&
2455 (!bta_hl_co_load_mdl_config(p_acb->app_id, BTA_HL_NUM_MDL_CFGS, &p_acb->mdl_cfg[0])))
2457 status = BTA_HL_STATUS_MDL_CFG_CO_FAIL;
2462 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2467 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2470 if (status == BTA_HL_STATUS_OK)
2472 status = bta_hl_sdp_register(app_idx);
2479 /*******************************************************************************
2481 ** Function bta_hl_discard_data
2483 ** Description This function discard an HDP event
2487 *******************************************************************************/
2488 void bta_hl_discard_data(UINT16 event, tBTA_HL_DATA *p_data)
2491 #if BTA_HL_DEBUG == TRUE
2492 APPL_TRACE_ERROR("BTA HL Discard event=%s",bta_hl_evt_code(event));
2498 case BTA_HL_API_SEND_DATA_EVT:
2501 case BTA_HL_MCA_RCV_DATA_EVT:
2502 utl_freebuf((void**)&p_data->mca_rcv_data_evt.p_pkt);
2511 /*******************************************************************************
2513 ** Function bta_hl_save_mdl_cfg
2515 ** Description This function saves the MDL configuration
2519 *******************************************************************************/
2520 void bta_hl_save_mdl_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx )
2522 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2523 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2524 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2526 tBTA_HL_MDL_ID mdl_id;
2528 tBTA_HL_MDL_CFG mdl_cfg;
2529 tBTA_HL_MDEP *p_mdep_cfg;
2530 tBTA_HL_L2CAP_CFG_INFO l2cap_cfg;
2532 mdl_id = p_dcb->mdl_id;
2533 if (!bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, mdl_id, &mdl_cfg_idx))
2535 if (!bta_hl_find_avail_mdl_cfg_idx(app_idx, mcl_idx, &mdl_cfg_idx))
2537 APPL_TRACE_ERROR("No space to save the MDL config");
2538 found= FALSE; /*no space available*/
2544 bta_hl_get_l2cap_cfg(p_dcb->mdl_handle, &l2cap_cfg);
2545 if (!bta_hl_get_cur_time(app_idx, &time_val ))
2547 bta_hl_compact_mdl_cfg_time(app_idx,p_dcb->local_mdep_id);
2548 bta_hl_get_cur_time(app_idx, &time_val);
2550 mdl_cfg.active = TRUE;
2551 mdl_cfg.time = time_val;
2552 mdl_cfg.mdl_id = p_dcb->mdl_id;
2553 mdl_cfg.dch_mode = p_dcb->dch_mode;
2554 mdl_cfg.mtu = l2cap_cfg.mtu;
2555 mdl_cfg.fcs = l2cap_cfg.fcs;
2557 bdcpy(mdl_cfg.peer_bd_addr, p_mcb->bd_addr);
2558 mdl_cfg.local_mdep_id= p_dcb->local_mdep_id;
2559 p_mdep_cfg = &p_acb->sup_feature.mdep[p_dcb->local_mdep_cfg_idx];
2560 mdl_cfg.local_mdep_role= p_mdep_cfg->mdep_cfg.mdep_role;
2561 memcpy(&p_acb->mdl_cfg[mdl_cfg_idx], &mdl_cfg, sizeof(tBTA_HL_MDL_CFG));
2562 bta_hl_co_save_mdl(mdl_cfg.local_mdep_id, mdl_cfg_idx, &mdl_cfg);
2565 #if BTA_HL_DEBUG == TRUE
2568 if (p_dcb->mtu != l2cap_cfg.mtu)
2570 APPL_TRACE_WARNING("MCAP and L2CAP peer mtu size out of sync from MCAP mtu=%d from l2cap mtu=%d",
2571 p_dcb->mtu, l2cap_cfg.mtu);
2573 APPL_TRACE_DEBUG("bta_hl_save_mdl_cfg saved=%d", found);
2574 APPL_TRACE_DEBUG("Saved. L2cap cfg mdl_id=%d mtu=%d fcs=%d dch_mode=%d",
2575 mdl_cfg.mdl_id, mdl_cfg.mtu, mdl_cfg.fcs, mdl_cfg.dch_mode);
2583 /*******************************************************************************
2585 ** Function bta_hl_set_dch_chan_cfg
2587 ** Description This function setups the L2CAP DCH channel configuration
2590 *******************************************************************************/
2591 void bta_hl_set_dch_chan_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,tBTA_HL_DATA *p_data)
2593 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2594 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2595 UINT8 l2cap_mode = L2CAP_FCR_ERTM_MODE;
2596 tBTA_HL_SUP_FEATURE *p_sup_feature= &p_acb->sup_feature;
2597 UINT8 local_mdep_cfg_idx = p_dcb->local_mdep_cfg_idx;
2599 switch (p_dcb->dch_oper)
2601 case BTA_HL_DCH_OP_LOCAL_RECONNECT:
2602 case BTA_HL_DCH_OP_REMOTE_RECONNECT:
2603 if (p_dcb->dch_mode == BTA_HL_DCH_MODE_STREAMING)
2604 l2cap_mode = L2CAP_FCR_STREAM_MODE;
2606 case BTA_HL_DCH_OP_LOCAL_OPEN:
2607 if (p_data->mca_evt.mca_data.create_cfm.cfg == BTA_HL_DCH_CFG_STREAMING)
2608 l2cap_mode = L2CAP_FCR_STREAM_MODE;
2610 case BTA_HL_DCH_OP_REMOTE_OPEN:
2611 if (p_dcb->local_cfg == BTA_HL_DCH_CFG_STREAMING )
2612 l2cap_mode = L2CAP_FCR_STREAM_MODE;
2615 APPL_TRACE_ERROR("Invalid dch oper=%d for set dch chan cfg", p_dcb->dch_oper);
2618 p_dcb->chnl_cfg.fcr_opt.mode = l2cap_mode;
2619 p_dcb->chnl_cfg.fcr_opt.mps = bta_hl_set_mps(p_dcb->max_rx_apdu_size);
2620 p_dcb->chnl_cfg.fcr_opt.tx_win_sz = bta_hl_set_tx_win_size(p_dcb->max_rx_apdu_size,
2621 p_dcb->chnl_cfg.fcr_opt.mps);
2622 p_dcb->chnl_cfg.fcr_opt.max_transmit= BTA_HL_L2C_MAX_TRANSMIT;
2623 p_dcb->chnl_cfg.fcr_opt.rtrans_tout = BTA_HL_L2C_RTRANS_TOUT;
2624 p_dcb->chnl_cfg.fcr_opt.mon_tout = BTA_HL_L2C_MON_TOUT;
2626 p_dcb->chnl_cfg.user_rx_pool_id = bta_hl_set_user_rx_pool_id(p_dcb->max_rx_apdu_size);
2627 p_dcb->chnl_cfg.user_tx_pool_id = bta_hl_set_user_tx_pool_id(p_dcb->max_tx_apdu_size);
2628 p_dcb->chnl_cfg.fcr_rx_pool_id = BTA_HL_L2C_FCR_RX_POOL_ID;
2629 p_dcb->chnl_cfg.fcr_tx_pool_id = BTA_HL_L2C_FCR_TX_POOL_ID;
2630 p_dcb->chnl_cfg.data_mtu = p_dcb->max_rx_apdu_size;
2632 p_dcb->chnl_cfg.fcs = BTA_HL_MCA_NO_FCS;
2633 if (local_mdep_cfg_idx != BTA_HL_ECHO_TEST_MDEP_CFG_IDX)
2635 if (p_sup_feature->mdep[local_mdep_cfg_idx].mdep_cfg.mdep_role ==
2636 BTA_HL_MDEP_ROLE_SOURCE)
2638 p_dcb->chnl_cfg.fcs = BTA_HL_DEFAULT_SOURCE_FCS;
2643 p_dcb->chnl_cfg.fcs = BTA_HL_MCA_USE_FCS;
2646 #if BTA_HL_DEBUG == TRUE
2647 APPL_TRACE_DEBUG("L2CAP Params l2cap_mode[3-ERTM 4-STREAM]=%d", l2cap_mode);
2648 APPL_TRACE_DEBUG("Use FCS =%s mtu=%d", ((p_dcb->chnl_cfg.fcs & 1)?"YES":"NO"),
2649 p_dcb->chnl_cfg.data_mtu);
2650 APPL_TRACE_DEBUG("tx_win_sz=%d, max_transmit=%d, rtrans_tout=%d, mon_tout=%d, mps=%d",
2651 p_dcb->chnl_cfg.fcr_opt.tx_win_sz,
2652 p_dcb->chnl_cfg.fcr_opt.max_transmit,
2653 p_dcb->chnl_cfg.fcr_opt.rtrans_tout,
2654 p_dcb->chnl_cfg.fcr_opt.mon_tout,
2655 p_dcb->chnl_cfg.fcr_opt.mps);
2657 APPL_TRACE_DEBUG("USER rx_pool_id=%d, tx_pool_id=%d, FCR rx_pool_id=%d, tx_pool_id=%d",
2658 p_dcb->chnl_cfg.user_rx_pool_id,
2659 p_dcb->chnl_cfg.user_tx_pool_id,
2660 p_dcb->chnl_cfg.fcr_rx_pool_id,
2661 p_dcb->chnl_cfg.fcr_tx_pool_id);
2674 /*******************************************************************************
2676 ** Function bta_hl_get_l2cap_cfg
2678 ** Description This function get the current L2CAP channel configuration
2680 ** Returns BOOLEAN - TRUE - operation is successful
2681 *******************************************************************************/
2682 BOOLEAN bta_hl_get_l2cap_cfg(tBTA_HL_MDL_HANDLE mdl_hnd, tBTA_HL_L2CAP_CFG_INFO *p_cfg)
2684 BOOLEAN success = FALSE;
2686 tL2CAP_CFG_INFO *p_our_cfg;
2687 tL2CAP_CH_CFG_BITS our_cfg_bits;
2688 tL2CAP_CFG_INFO *p_peer_cfg;
2689 tL2CAP_CH_CFG_BITS peer_cfg_bits;
2691 lcid = MCA_GetL2CapChannel((tMCA_DL) mdl_hnd);
2693 L2CA_GetCurrentConfig(lcid, &p_our_cfg, &our_cfg_bits, &p_peer_cfg,
2696 p_cfg->fcs = BTA_HL_MCA_NO_FCS;
2697 if (our_cfg_bits & L2CAP_CH_CFG_MASK_FCS)
2699 p_cfg->fcs |= p_our_cfg->fcs;
2703 p_cfg->fcs = BTA_HL_MCA_USE_FCS;
2706 if (p_cfg->fcs != BTA_HL_MCA_USE_FCS )
2708 if (peer_cfg_bits & L2CAP_CH_CFG_MASK_FCS)
2710 p_cfg->fcs |= p_peer_cfg->fcs;
2714 p_cfg->fcs = BTA_HL_MCA_USE_FCS;
2719 if (peer_cfg_bits & L2CAP_CH_CFG_MASK_MTU)
2721 p_cfg->mtu = p_peer_cfg->mtu;
2725 p_cfg->mtu = L2CAP_DEFAULT_MTU;
2731 p_cfg->mtu = L2CAP_DEFAULT_MTU;
2732 p_cfg->fcs = BTA_HL_L2C_NO_FCS;
2735 #if BTA_HL_DEBUG == TRUE
2738 APPL_TRACE_DEBUG("bta_hl_get_l2cap_cfg success=%d mdl=%d lcid=%d", success, mdl_hnd, lcid);
2739 APPL_TRACE_DEBUG("l2cap mtu=%d fcs=%d", p_cfg->mtu, p_cfg->fcs);
2746 /*******************************************************************************
2748 ** Function bta_hl_validate_chan_cfg
2750 ** Description This function validates the L2CAP channel configuration
2752 ** Returns BOOLEAN - TRUE - validation is successful
2753 *******************************************************************************/
2754 BOOLEAN bta_hl_validate_chan_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx)
2756 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2757 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2758 BOOLEAN success = FALSE;
2759 UINT8 mdl_cfg_idx = 0;
2760 tBTA_HL_L2CAP_CFG_INFO l2cap_cfg;
2761 BOOLEAN get_l2cap_result, get_mdl_result;
2763 get_l2cap_result = bta_hl_get_l2cap_cfg(p_dcb->mdl_handle, &l2cap_cfg);
2764 get_mdl_result = bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, p_dcb->mdl_id, &mdl_cfg_idx);
2766 if (get_l2cap_result && get_mdl_result)
2768 if ((p_acb->mdl_cfg[mdl_cfg_idx].mtu <= l2cap_cfg.mtu) &&
2769 (p_acb->mdl_cfg[mdl_cfg_idx].fcs == l2cap_cfg.fcs) &&
2770 (p_acb->mdl_cfg[mdl_cfg_idx].dch_mode == p_dcb->dch_mode))
2777 #if BTA_HL_DEBUG == TRUE
2779 if (p_dcb->mtu != l2cap_cfg.mtu)
2781 APPL_TRACE_WARNING("MCAP and L2CAP peer mtu size out of sync from MCAP mtu=%d from l2cap mtu=%d",
2782 p_dcb->mtu, l2cap_cfg.mtu);
2787 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);
2788 APPL_TRACE_DEBUG("Cur. L2cap cfg mtu=%d fcs=%d dch_mode=%d", l2cap_cfg.mtu, l2cap_cfg.fcs, p_dcb->dch_mode);
2789 APPL_TRACE_DEBUG("From saved: L2cap cfg mtu=%d fcs=%d dch_mode=%d", p_acb->mdl_cfg[mdl_cfg_idx].mtu,
2790 p_acb->mdl_cfg[mdl_cfg_idx].fcs , p_acb->mdl_cfg[mdl_cfg_idx].dch_mode);
2798 /*******************************************************************************
2800 ** Function bta_hl_is_cong_on
2802 ** Description This function checks whether the congestion condition is on or not
2804 ** Returns BOOLEAN - TRUE DCH is congested
2805 ** FALSE not congested
2807 *******************************************************************************/
2808 BOOLEAN bta_hl_is_cong_on(UINT8 app_id, BD_ADDR bd_addr, tBTA_HL_MDL_ID mdl_id)
2811 tBTA_HL_MDL_CB *p_dcb;
2812 UINT8 app_idx = 0, mcl_idx, mdl_idx;
2813 BOOLEAN cong_status = TRUE;
2815 if (bta_hl_find_app_idx(app_id, &app_idx))
2817 if (bta_hl_find_mcl_idx(app_idx, bd_addr, &mcl_idx ))
2819 if (bta_hl_find_mdl_idx(app_idx, mcl_idx, mdl_id, &mdl_idx ))
2821 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2822 cong_status = p_dcb->cong;
2830 /*******************************************************************************
2832 ** Function bta_hl_check_cch_close
2834 ** Description This function checks whether there is a pending CCH close request
2838 *******************************************************************************/
2839 void bta_hl_check_cch_close(UINT8 app_idx, UINT8 mcl_idx, tBTA_HL_DATA *p_data, BOOLEAN check_dch_setup )
2841 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2842 tBTA_HL_MDL_CB *p_dcb;
2845 #if (BTA_HL_DEBUG == TRUE)
2846 APPL_TRACE_DEBUG("bta_hl_check_cch_close cch_close_dch_oper=%d",p_mcb->cch_close_dch_oper );
2849 if (p_mcb->cch_oper == BTA_HL_CCH_OP_LOCAL_CLOSE)
2851 if (check_dch_setup && bta_hl_find_dch_setup_mdl_idx(app_idx, mcl_idx, &mdl_idx))
2853 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2854 if (!p_mcb->rsp_tout)
2856 p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_ABORT;
2858 if (!p_dcb->abort_oper)
2860 p_dcb->abort_oper |= BTA_HL_ABORT_CCH_CLOSE_MASK;
2861 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_ABORT_EVT, p_data);
2866 p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_CLOSE;
2867 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
2870 else if (bta_hl_find_an_active_mdl_idx(app_idx, mcl_idx,&mdl_idx))
2872 p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_CLOSE;
2873 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_EVT, p_data);
2877 p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_NONE;
2878 bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_CLOSE_EVT, p_data);
2883 /*******************************************************************************
2885 ** Function bta_hl_clean_app
2887 ** Description Cleans up the HDP application resources and control block
2891 *******************************************************************************/
2892 void bta_hl_clean_app(UINT8 app_idx)
2894 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2895 int i, num_act_apps=0;
2897 #if BTA_HL_DEBUG == TRUE
2898 APPL_TRACE_DEBUG("bta_hl_clean_app");
2900 MCA_Deregister((tMCA_HANDLE)p_acb->app_handle);
2902 if (p_acb->sdp_handle) SDP_DeleteRecord(p_acb->sdp_handle);
2904 memset((void *) p_acb, 0, sizeof(tBTA_HL_APP_CB));
2906 /* check any application is still active */
2907 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
2909 p_acb = BTA_HL_GET_APP_CB_PTR(i);
2910 if (p_acb->in_use) num_act_apps++;
2915 bta_sys_remove_uuid(UUID_SERVCLASS_HDP_PROFILE);
2919 /*******************************************************************************
2921 ** Function bta_hl_check_deregistration
2923 ** Description This function checks whether there is a pending deregistration
2927 *******************************************************************************/
2928 void bta_hl_check_deregistration(UINT8 app_idx, tBTA_HL_DATA *p_data )
2930 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2931 tBTA_HL_MCL_CB *p_mcb;
2935 #if (BTA_HL_DEBUG == TRUE)
2936 APPL_TRACE_DEBUG("bta_hl_check_deregistration");
2939 if (p_acb->deregistering)
2941 if (bta_hl_find_an_in_use_mcl_idx(app_idx, &mcl_idx))
2943 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2944 if (p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_CLOSE)
2946 if (p_mcb->cch_state == BTA_HL_CCH_OPENING_ST)
2947 p_mcb->force_close_local_cch_opening = TRUE;
2948 p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_CLOSE;
2949 APPL_TRACE_DEBUG("p_mcb->force_close_local_cch_opening=%d", p_mcb->force_close_local_cch_opening );
2950 bta_hl_check_cch_close(app_idx,mcl_idx,p_data, TRUE);
2955 /* all cchs are closed */
2956 evt_data.dereg_cfm.app_handle = p_acb->app_handle;
2957 evt_data.dereg_cfm.app_id = p_data->api_dereg.app_id;
2958 evt_data.dereg_cfm.status = BTA_HL_STATUS_OK;
2959 p_acb->p_cback(BTA_HL_DEREGISTER_CFM_EVT, (tBTA_HL *) &evt_data );
2960 bta_hl_clean_app(app_idx);
2961 bta_hl_check_disable(p_data);
2967 /*******************************************************************************
2969 ** Function bta_hl_check_disable
2971 ** Description This function checks whether there is a pending disable
2976 *******************************************************************************/
2977 void bta_hl_check_disable(tBTA_HL_DATA *p_data )
2979 tBTA_HL_CB *p_cb= &bta_hl_cb;
2980 tBTA_HL_APP_CB *p_acb;
2982 tBTA_HL_CTRL evt_data;
2984 #if (BTA_HL_DEBUG == TRUE)
2985 APPL_TRACE_DEBUG("bta_hl_check_disable");
2988 if (bta_hl_cb.disabling)
2990 if (bta_hl_find_an_in_use_app_idx(&app_idx))
2992 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2993 if (!p_acb->deregistering)
2995 p_acb->deregistering = TRUE;
2996 bta_hl_check_deregistration(app_idx, p_data);
3001 /* all apps are deregistered */
3002 bta_sys_deregister(BTA_ID_HL);
3003 evt_data.disable_cfm.status = BTA_HL_STATUS_OK;
3004 if (p_cb->p_ctrl_cback) p_cb->p_ctrl_cback(BTA_HL_CTRL_DISABLE_CFM_EVT, (tBTA_HL_CTRL *) &evt_data);
3005 memset((void *) p_cb, 0, sizeof(tBTA_HL_CB));
3010 /*******************************************************************************
3012 ** Function bta_hl_build_abort_cfm
3014 ** Description This function builds the abort confirmation event data
3018 *******************************************************************************/
3019 void bta_hl_build_abort_cfm(tBTA_HL *p_evt_data,
3020 tBTA_HL_APP_HANDLE app_handle,
3021 tBTA_HL_MCL_HANDLE mcl_handle,
3022 tBTA_HL_STATUS status)
3024 p_evt_data->dch_abort_cfm.status = status;
3025 p_evt_data->dch_abort_cfm.mcl_handle = mcl_handle;
3026 p_evt_data->dch_abort_cfm.app_handle = app_handle;
3029 /*******************************************************************************
3031 ** Function bta_hl_build_abort_ind
3033 ** Description This function builds the abort indication event data
3037 *******************************************************************************/
3038 void bta_hl_build_abort_ind(tBTA_HL *p_evt_data,
3039 tBTA_HL_APP_HANDLE app_handle,
3040 tBTA_HL_MCL_HANDLE mcl_handle)
3042 p_evt_data->dch_abort_ind.mcl_handle = mcl_handle;
3043 p_evt_data->dch_abort_ind.app_handle = app_handle;
3045 /*******************************************************************************
3047 ** Function bta_hl_build_close_cfm
3049 ** Description This function builds the close confirmation event data
3053 *******************************************************************************/
3054 void bta_hl_build_dch_close_cfm(tBTA_HL *p_evt_data,
3055 tBTA_HL_APP_HANDLE app_handle,
3056 tBTA_HL_MCL_HANDLE mcl_handle,
3057 tBTA_HL_MDL_HANDLE mdl_handle,
3058 tBTA_HL_STATUS status)
3060 p_evt_data->dch_close_cfm.status = status;
3061 p_evt_data->dch_close_cfm.mdl_handle = mdl_handle;
3062 p_evt_data->dch_close_cfm.mcl_handle = mcl_handle;
3063 p_evt_data->dch_close_cfm.app_handle = app_handle;
3066 /*******************************************************************************
3068 ** Function bta_hl_build_dch_close_ind
3070 ** Description This function builds the close indication event data
3074 *******************************************************************************/
3075 void bta_hl_build_dch_close_ind(tBTA_HL *p_evt_data,
3076 tBTA_HL_APP_HANDLE app_handle,
3077 tBTA_HL_MCL_HANDLE mcl_handle,
3078 tBTA_HL_MDL_HANDLE mdl_handle,
3079 BOOLEAN intentional)
3081 p_evt_data->dch_close_ind.mdl_handle = mdl_handle;
3082 p_evt_data->dch_close_ind.mcl_handle = mcl_handle;
3083 p_evt_data->dch_close_ind.app_handle = app_handle;
3084 p_evt_data->dch_close_ind.intentional = intentional;
3087 /*******************************************************************************
3089 ** Function bta_hl_build_send_data_cfm
3091 ** Description This function builds the send data confirmation event data
3095 *******************************************************************************/
3096 void bta_hl_build_send_data_cfm(tBTA_HL *p_evt_data,
3097 tBTA_HL_APP_HANDLE app_handle,
3098 tBTA_HL_MCL_HANDLE mcl_handle,
3099 tBTA_HL_MDL_HANDLE mdl_handle,
3100 tBTA_HL_STATUS status )
3103 p_evt_data->dch_send_data_cfm.mdl_handle = mdl_handle;
3104 p_evt_data->dch_send_data_cfm.mcl_handle = mcl_handle;
3105 p_evt_data->dch_send_data_cfm.app_handle = app_handle;
3106 p_evt_data->dch_send_data_cfm.status = status;
3109 /*******************************************************************************
3111 ** Function bta_hl_build_rcv_data_ind
3113 ** Description This function builds the received data indication event data
3117 *******************************************************************************/
3118 void bta_hl_build_rcv_data_ind(tBTA_HL *p_evt_data,
3119 tBTA_HL_APP_HANDLE app_handle,
3120 tBTA_HL_MCL_HANDLE mcl_handle,
3121 tBTA_HL_MDL_HANDLE mdl_handle)
3123 p_evt_data->dch_rcv_data_ind.mdl_handle = mdl_handle;
3124 p_evt_data->dch_rcv_data_ind.mcl_handle = mcl_handle;
3125 p_evt_data->dch_rcv_data_ind.app_handle = app_handle;
3129 /*******************************************************************************
3131 ** Function bta_hl_build_cch_open_cfm
3133 ** Description This function builds the CCH open confirmation event data
3137 *******************************************************************************/
3138 void bta_hl_build_cch_open_cfm(tBTA_HL *p_evt_data,
3140 tBTA_HL_APP_HANDLE app_handle,
3141 tBTA_HL_MCL_HANDLE mcl_handle,
3143 tBTA_HL_STATUS status )
3145 p_evt_data->cch_open_cfm.app_id = app_id;
3146 p_evt_data->cch_open_cfm.app_handle = app_handle;
3147 p_evt_data->cch_open_cfm.mcl_handle = mcl_handle;
3148 bdcpy(p_evt_data->cch_open_cfm.bd_addr, bd_addr);
3149 p_evt_data->cch_open_cfm.status = status;
3150 APPL_TRACE_DEBUG("bta_hl_build_cch_open_cfm: status=%d",status);
3153 /*******************************************************************************
3155 ** Function bta_hl_build_cch_open_ind
3157 ** Description This function builds the CCH open indication event data
3161 *******************************************************************************/
3162 void bta_hl_build_cch_open_ind(tBTA_HL *p_evt_data, tBTA_HL_APP_HANDLE app_handle,
3163 tBTA_HL_MCL_HANDLE mcl_handle,
3167 p_evt_data->cch_open_ind.app_handle = app_handle;
3168 p_evt_data->cch_open_ind.mcl_handle = mcl_handle;
3169 bdcpy(p_evt_data->cch_open_ind.bd_addr, bd_addr);
3172 /*******************************************************************************
3174 ** Function bta_hl_build_cch_close_cfm
3176 ** Description This function builds the CCH close confirmation event data
3180 *******************************************************************************/
3181 void bta_hl_build_cch_close_cfm(tBTA_HL *p_evt_data,
3182 tBTA_HL_APP_HANDLE app_handle,
3183 tBTA_HL_MCL_HANDLE mcl_handle,
3184 tBTA_HL_STATUS status )
3186 p_evt_data->cch_close_cfm.mcl_handle = mcl_handle;
3187 p_evt_data->cch_close_cfm.app_handle = app_handle;
3188 p_evt_data->cch_close_cfm.status = status;
3192 /*******************************************************************************
3194 ** Function bta_hl_build_cch_close_ind
3196 ** Description This function builds the CCH colse indication event data
3200 *******************************************************************************/
3201 void bta_hl_build_cch_close_ind(tBTA_HL *p_evt_data,
3202 tBTA_HL_APP_HANDLE app_handle,
3203 tBTA_HL_MCL_HANDLE mcl_handle,
3204 BOOLEAN intentional)
3206 p_evt_data->cch_close_ind.mcl_handle = mcl_handle;
3207 p_evt_data->cch_close_ind.app_handle = app_handle;
3208 p_evt_data->cch_close_ind.intentional = intentional;
3211 /*******************************************************************************
3213 ** Function bta_hl_build_dch_open_cfm
3215 ** Description This function builds the DCH open confirmation event data
3219 *******************************************************************************/
3220 void bta_hl_build_dch_open_cfm(tBTA_HL *p_evt_data,
3221 tBTA_HL_APP_HANDLE app_handle,
3222 tBTA_HL_MCL_HANDLE mcl_handle,
3223 tBTA_HL_MDL_HANDLE mdl_handle,
3224 tBTA_HL_MDEP_ID local_mdep_id,
3225 tBTA_HL_MDL_ID mdl_id,
3226 tBTA_HL_DCH_MODE dch_mode,
3227 BOOLEAN first_reliable,
3229 tBTA_HL_STATUS status)
3232 p_evt_data->dch_open_cfm.mdl_handle = mdl_handle;
3233 p_evt_data->dch_open_cfm.mcl_handle = mcl_handle;
3234 p_evt_data->dch_open_cfm.app_handle = app_handle;
3235 p_evt_data->dch_open_cfm.local_mdep_id = local_mdep_id;
3236 p_evt_data->dch_open_cfm.mdl_id = mdl_id;
3237 p_evt_data->dch_open_cfm.dch_mode = dch_mode;
3238 p_evt_data->dch_open_cfm.first_reliable = first_reliable;
3239 p_evt_data->dch_open_cfm.mtu = mtu;
3240 p_evt_data->dch_open_cfm.status = status;
3244 /*******************************************************************************
3246 ** Function bta_hl_build_sdp_query_cfm
3248 ** Description This function builds the SDP query indication event data
3252 *******************************************************************************/
3253 void bta_hl_build_sdp_query_cfm(tBTA_HL *p_evt_data,
3255 tBTA_HL_APP_HANDLE app_handle,
3258 tBTA_HL_STATUS status)
3261 APPL_TRACE_DEBUG("bta_hl_build_sdp_query_cfm: app_id = %d, app_handle=%d",
3263 p_evt_data->sdp_query_cfm.app_id = app_id;
3264 p_evt_data->sdp_query_cfm.app_handle = app_handle;
3265 bdcpy(p_evt_data->sdp_query_cfm.bd_addr, bd_addr);
3266 p_evt_data->sdp_query_cfm.p_sdp = p_sdp;
3267 p_evt_data->sdp_query_cfm.status = status;
3271 /*******************************************************************************
3273 ** Function bta_hl_build_delete_mdl_cfm
3275 ** Description This function builds the delete MDL confirmation event data
3279 *******************************************************************************/
3280 void bta_hl_build_delete_mdl_cfm(tBTA_HL *p_evt_data,
3281 tBTA_HL_APP_HANDLE app_handle,
3282 tBTA_HL_MCL_HANDLE mcl_handle,
3283 tBTA_HL_MDL_ID mdl_id,
3284 tBTA_HL_STATUS status)
3287 p_evt_data->delete_mdl_cfm.mcl_handle = mcl_handle;
3288 p_evt_data->delete_mdl_cfm.app_handle = app_handle;
3289 p_evt_data->delete_mdl_cfm.mdl_id = mdl_id;
3290 p_evt_data->delete_mdl_cfm.status = status;
3293 /*******************************************************************************
3295 ** Function bta_hl_build_echo_test_cfm
3297 ** Description This function builds the echo test confirmation event data
3301 *******************************************************************************/
3302 void bta_hl_build_echo_test_cfm(tBTA_HL *p_evt_data,
3303 tBTA_HL_APP_HANDLE app_handle,
3304 tBTA_HL_MCL_HANDLE mcl_handle,
3305 tBTA_HL_STATUS status )
3307 p_evt_data->echo_test_cfm.mcl_handle = mcl_handle;
3308 p_evt_data->echo_test_cfm.app_handle = app_handle;
3309 p_evt_data->echo_test_cfm.status = status;
3313 /*****************************************************************************
3315 *****************************************************************************/
3316 #if (BTA_HL_DEBUG == TRUE)
3318 /*******************************************************************************
3320 ** Function bta_hl_status_code
3322 ** Description get the status string pointer
3324 ** Returns char * - status string pointer
3326 *******************************************************************************/
3327 char *bta_hl_status_code(tBTA_HL_STATUS status)
3331 case BTA_HL_STATUS_OK:
3332 return "BTA_HL_STATUS_OK";
3333 case BTA_HL_STATUS_FAIL:
3334 return "BTA_HL_STATUS_FAIL";
3335 case BTA_HL_STATUS_ABORTED:
3336 return "BTA_HL_STATUS_ABORTED";
3337 case BTA_HL_STATUS_NO_RESOURCE:
3338 return "BTA_HL_STATUS_NO_RESOURCE";
3339 case BTA_HL_STATUS_LAST_ITEM:
3340 return "BTA_HL_STATUS_LAST_ITEM";
3341 case BTA_HL_STATUS_DUPLICATE_APP_ID:
3342 return "BTA_HL_STATUS_DUPLICATE_APP_ID";
3343 case BTA_HL_STATUS_INVALID_APP_HANDLE:
3344 return "BTA_HL_STATUS_INVALID_APP_HANDLE";
3345 case BTA_HL_STATUS_INVALID_MCL_HANDLE:
3346 return "BTA_HL_STATUS_INVALID_MCL_HANDLE";
3347 case BTA_HL_STATUS_MCAP_REG_FAIL:
3348 return "BTA_HL_STATUS_MCAP_REG_FAIL";
3349 case BTA_HL_STATUS_MDEP_CO_FAIL:
3350 return "BTA_HL_STATUS_MDEP_CO_FAIL";
3351 case BTA_HL_STATUS_ECHO_CO_FAIL:
3352 return "BTA_HL_STATUS_ECHO_CO_FAIL";
3353 case BTA_HL_STATUS_MDL_CFG_CO_FAIL:
3354 return "BTA_HL_STATUS_MDL_CFG_CO_FAIL";
3355 case BTA_HL_STATUS_SDP_NO_RESOURCE:
3356 return "BTA_HL_STATUS_SDP_NO_RESOURCE";
3357 case BTA_HL_STATUS_SDP_FAIL:
3358 return "BTA_HL_STATUS_SDP_FAIL";
3359 case BTA_HL_STATUS_NO_CCH:
3360 return "BTA_HL_STATUS_NO_CCH";
3361 case BTA_HL_STATUS_NO_MCL:
3362 return "BTA_HL_STATUS_NO_MCL";
3364 case BTA_HL_STATUS_NO_FIRST_RELIABLE:
3365 return "BTA_HL_STATUS_NO_FIRST_RELIABLE";
3366 case BTA_HL_STATUS_INVALID_DCH_CFG:
3367 return "BTA_HL_STATUS_INVALID_DCH_CFG";
3368 case BTA_HL_STATUS_INVALID_BD_ADDR:
3369 return "BTA_HL_STATUS_INVALID_BD_ADDR";
3370 case BTA_HL_STATUS_INVALID_RECONNECT_CFG:
3371 return "BTA_HL_STATUS_INVALID_RECONNECT_CFG";
3372 case BTA_HL_STATUS_ECHO_TEST_BUSY:
3373 return "BTA_HL_STATUS_ECHO_TEST_BUSY";
3374 case BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID:
3375 return "BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID";
3376 case BTA_HL_STATUS_INVALID_MDL_ID:
3377 return "BTA_HL_STATUS_INVALID_MDL_ID";
3378 case BTA_HL_STATUS_NO_MDL_ID_FOUND:
3379 return "BTA_HL_STATUS_NO_MDL_ID_FOUND";
3380 case BTA_HL_STATUS_DCH_BUSY:
3381 return "BTA_HL_STATUS_DCH_BUSY";
3383 return "Unknown status code";
3386 /*******************************************************************************
3388 ** Function bta_hl_evt_code
3390 ** Description Maps HL event code to the corresponding event string
3392 ** Returns string pointer for the associated event name
3394 *******************************************************************************/
3395 char *bta_hl_evt_code(tBTA_HL_INT_EVT evt_code)
3399 case BTA_HL_CCH_OPEN_EVT:
3400 return "BTA_HL_CCH_OPEN_EVT";
3401 case BTA_HL_CCH_SDP_OK_EVT:
3402 return "BTA_HL_CCH_SDP_OK_EVT";
3403 case BTA_HL_CCH_SDP_FAIL_EVT:
3404 return "BTA_HL_CCH_SDP_FAIL_EVT";
3405 case BTA_HL_MCA_CONNECT_IND_EVT:
3406 return "BTA_HL_MCA_CONNECT_IND_EVT";
3407 case BTA_HL_MCA_DISCONNECT_IND_EVT:
3408 return "BTA_HL_MCA_DISCONNECT_IND_EVT";
3410 case BTA_HL_CCH_CLOSE_EVT:
3411 return "BTA_HL_CCH_CLOSE_EVT";
3412 case BTA_HL_CCH_CLOSE_CMPL_EVT:
3413 return "BTA_HL_CCH_CLOSE_CMPL_EVT";
3414 case BTA_HL_DCH_OPEN_EVT:
3415 return "BTA_HL_DCH_OPEN_EVT";
3416 case BTA_HL_MCA_CREATE_IND_EVT:
3417 return "BTA_HL_MCA_CREATE_IND_EVT";
3418 case BTA_HL_MCA_CREATE_CFM_EVT:
3419 return "BTA_HL_MCA_CREATE_CFM_EVT";
3420 case BTA_HL_MCA_OPEN_IND_EVT:
3421 return "BTA_HL_MCA_OPEN_IND_EVT";
3422 case BTA_HL_MCA_OPEN_CFM_EVT:
3423 return "BTA_HL_MCA_OPEN_CFM_EVT";
3424 case BTA_HL_DCH_CLOSE_EVT:
3425 return "BTA_HL_DCH_CLOSE_EVT";
3426 case BTA_HL_MCA_CLOSE_IND_EVT:
3427 return "BTA_HL_MCA_CLOSE_IND_EVT";
3428 case BTA_HL_MCA_CLOSE_CFM_EVT:
3429 return "BTA_HL_MCA_CLOSE_CFM_EVT";
3430 case BTA_HL_API_SEND_DATA_EVT:
3431 return "BTA_HL_API_SEND_DATA_EVT";
3432 case BTA_HL_MCA_RCV_DATA_EVT:
3433 return "BTA_HL_MCA_RCV_DATA_EVT";
3434 case BTA_HL_DCH_CLOSE_CMPL_EVT:
3435 return "BTA_HL_DCH_CLOSE_CMPL_EVT";
3437 case BTA_HL_API_ENABLE_EVT:
3438 return "BTA_HL_API_ENABLE_EVT";
3439 case BTA_HL_API_DISABLE_EVT:
3440 return "BTA_HL_API_DISABLE_EVT";
3441 case BTA_HL_API_UPDATE_EVT:
3442 return "BTA_HL_API_UPDATE_EVT";
3443 case BTA_HL_API_REGISTER_EVT:
3444 return "BTA_HL_API_REGISTER_EVT";
3445 case BTA_HL_API_DEREGISTER_EVT:
3446 return "BTA_HL_API_DEREGISTER_EVT";
3448 case BTA_HL_API_CCH_OPEN_EVT:
3449 return "BTA_HL_API_CCH_OPEN_EVT";
3451 case BTA_HL_API_CCH_CLOSE_EVT:
3452 return "BTA_HL_API_CCH_CLOSE_EVT";
3453 case BTA_HL_API_DCH_OPEN_EVT:
3454 return "BTA_HL_API_DCH_OPEN_EVT";
3456 case BTA_HL_API_DCH_RECONNECT_EVT:
3457 return "BTA_HL_API_DCH_RECONNECT_EVT";
3458 case BTA_HL_API_DCH_CLOSE_EVT:
3459 return "BTA_HL_API_DCH_CLOSE_EVT";
3460 case BTA_HL_API_DELETE_MDL_EVT:
3461 return "BTA_HL_API_DELETE_MDL_EVT";
3462 case BTA_HL_API_DCH_ABORT_EVT:
3463 return "BTA_HL_API_DCH_ABORT_EVT";
3465 case BTA_HL_DCH_RECONNECT_EVT:
3466 return "BTA_HL_DCH_RECONNECT_EVT";
3467 case BTA_HL_DCH_SDP_INIT_EVT:
3468 return "BTA_HL_DCH_SDP_INIT_EVT";
3469 case BTA_HL_DCH_SDP_FAIL_EVT:
3470 return "BTA_HL_DCH_SDP_FAIL_EVT";
3471 case BTA_HL_API_DCH_ECHO_TEST_EVT:
3472 return "BTA_HL_API_DCH_ECHO_TEST_EVT";
3473 case BTA_HL_DCH_CLOSE_ECHO_TEST_EVT:
3474 return "BTA_HL_DCH_CLOSE_ECHO_TEST_EVT";
3475 case BTA_HL_MCA_RECONNECT_IND_EVT:
3476 return "BTA_HL_MCA_RECONNECT_IND_EVT";
3477 case BTA_HL_MCA_RECONNECT_CFM_EVT:
3478 return "BTA_HL_MCA_RECONNECT_CFM_EVT";
3479 case BTA_HL_API_DCH_CREATE_RSP_EVT:
3480 return "BTA_HL_API_DCH_CREATE_RSP_EVT";
3481 case BTA_HL_DCH_ABORT_EVT:
3482 return "BTA_HL_DCH_ABORT_EVT";
3483 case BTA_HL_MCA_ABORT_IND_EVT:
3484 return "BTA_HL_MCA_ABORT_IND_EVT";
3485 case BTA_HL_MCA_ABORT_CFM_EVT:
3486 return "BTA_HL_MCA_ABORT_CFM_EVT";
3487 case BTA_HL_MCA_DELETE_IND_EVT:
3488 return "BTA_HL_MCA_DELETE_IND_EVT";
3489 case BTA_HL_MCA_DELETE_CFM_EVT:
3490 return "BTA_HL_MCA_DELETE_CFM_EVT";
3491 case BTA_HL_MCA_CONG_CHG_EVT:
3492 return "BTA_HL_MCA_CONG_CHG_EVT";
3493 case BTA_HL_CI_GET_TX_DATA_EVT:
3494 return "BTA_HL_CI_GET_TX_DATA_EVT";
3495 case BTA_HL_CI_PUT_RX_DATA_EVT:
3496 return "BTA_HL_CI_PUT_RX_DATA_EVT";
3497 case BTA_HL_CI_GET_ECHO_DATA_EVT:
3498 return "BTA_HL_CI_GET_ECHO_DATA_EVT";
3499 case BTA_HL_DCH_ECHO_TEST_EVT:
3500 return "BTA_HL_DCH_ECHO_TEST_EVT";
3501 case BTA_HL_CI_PUT_ECHO_DATA_EVT:
3502 return "BTA_HL_CI_PUT_ECHO_DATA_EVT";
3503 case BTA_HL_API_SDP_QUERY_EVT:
3504 return "BTA_HL_API_SDP_QUERY_EVT";
3505 case BTA_HL_SDP_QUERY_OK_EVT:
3506 return "BTA_HL_SDP_QUERY_OK_EVT";
3507 case BTA_HL_SDP_QUERY_FAIL_EVT:
3508 return "BTA_HL_SDP_QUERY_FAIL_EVT";
3509 case BTA_HL_MCA_RSP_TOUT_IND_EVT:
3510 return "BTA_HL_MCA_RSP_TOUT_IND_EVT";
3513 return "Unknown HL event code";
3517 #endif /* Debug Functions */
3518 #endif // HL_INCLUDED