1 /******************************************************************************
3 * Copyright (C) 2009-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 /************************************************************************************
23 * Description: Health Device Profile Bluetooth Interface
26 ***********************************************************************************/
27 #define LOG_TAG "BTIF_HL"
33 #include <sys/types.h>
34 #include <sys/socket.h>
42 #include <sys/select.h>
44 #include <sys/prctl.h>
45 #include <cutils/sockets.h>
46 #include <cutils/log.h>
48 #include <hardware/bluetooth.h>
49 #include <hardware/bt_hl.h>
51 #include "btif_common.h"
52 #include "btif_util.h"
56 #include "bta_hl_api.h"
59 #include "btif_storage.h"
62 #define MAX_DATATYPE_SUPPORTED 8
64 extern int btif_hl_update_maxfd( int max_org_s);
65 extern void btif_hl_select_monitor_callback( fd_set *p_cur_set, fd_set *p_org_set );
66 extern void btif_hl_select_wakeup_callback( fd_set *p_org_set , int wakeup_signal );
67 extern int btif_hl_update_maxfd( int max_org_s);
68 extern void btif_hl_select_monitor_callback( fd_set *p_cur_set, fd_set *p_org_set );
69 extern void btif_hl_select_wakeup_callback( fd_set *p_org_set , int wakeup_signal );
70 extern void btif_hl_soc_thread_init(void);
71 extern void btif_hl_release_mcl_sockets(UINT8 app_idx, UINT8 mcl_idx);
72 extern BOOLEAN btif_hl_create_socket(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx);
73 extern void btif_hl_release_socket(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx);
75 btif_hl_cb_t btif_hl_cb;
76 btif_hl_cb_t *p_btif_hl_cb = &btif_hl_cb;
78 /************************************************************************************
80 ************************************************************************************/
81 static bthl_callbacks_t bt_hl_callbacks_cb;
82 static bthl_callbacks_t *bt_hl_callbacks=NULL;
84 /* signal socketpair to wake up select loop */
86 const int btif_hl_signal_select_wakeup = 1;
87 const int btif_hl_signal_select_exit = 2;
88 const int btif_hl_signal_select_close_connected = 3;
90 static int listen_s = -1;
91 static int connected_s = -1;
92 static int select_thread_id = -1;
93 static int signal_fds[2] = { -1, -1 };
94 static BUFFER_Q soc_queue;
95 static int reg_counter;
97 static inline int btif_hl_select_wakeup(void);
98 static inline int btif_hl_select_close_connected(void);
99 static inline int btif_hl_close_select_thread(void);
100 static UINT8 btif_hl_get_next_app_id(void);
101 static int btif_hl_get_next_channel_id(UINT8 app_id);
102 static void btif_hl_init_next_app_id(void);
103 static void btif_hl_init_next_channel_id(void);
104 static void btif_hl_ctrl_cback(tBTA_HL_CTRL_EVT event, tBTA_HL_CTRL *p_data);
105 static void btif_hl_set_state(btif_hl_state_t state);
106 static btif_hl_state_t btif_hl_get_state(void);
107 static void btif_hl_cback(tBTA_HL_EVT event, tBTA_HL *p_data);
108 static void btif_hl_proc_cb_evt(UINT16 event, char* p_param);
110 #define CHECK_CALL_CBACK(P_CB, P_CBACK, ...)\
111 if (P_CB && P_CB->P_CBACK) { \
112 P_CB->P_CBACK(__VA_ARGS__); \
115 ASSERTC(0, "Callback is NULL", 0); \
119 #define BTIF_HL_CALL_CBACK(P_CB, P_CBACK, ...)\
120 if((p_btif_hl_cb->state != BTIF_HL_STATE_DISABLING) &&\
121 (p_btif_hl_cb->state != BTIF_HL_STATE_DISABLED)) \
123 if (P_CB && P_CB->P_CBACK) { \
124 P_CB->P_CBACK(__VA_ARGS__); \
127 ASSERTC(0, "Callback is NULL", 0); \
132 #define CHECK_BTHL_INIT() if (bt_hl_callbacks == NULL)\
134 BTIF_TRACE_WARNING("BTHL: %s: BTHL not initialized", __FUNCTION__);\
135 return BT_STATUS_NOT_READY;\
139 BTIF_TRACE_EVENT("BTHL: %s", __FUNCTION__);\
143 static const btif_hl_data_type_cfg_t data_type_table[] = {
144 /* Data Specilization Ntx Nrx (from Bluetooth SIG's HDP whitepaper)*/
145 {BTIF_HL_DATA_TYPE_PULSE_OXIMETER, 9216, 256},
146 {BTIF_HL_DATA_TYPE_BLOOD_PRESSURE_MON, 896, 224},
147 {BTIF_HL_DATA_TYPE_BODY_THERMOMETER, 896, 224},
148 {BTIF_HL_DATA_TYPE_BODY_WEIGHT_SCALE, 896, 224},
149 {BTIF_HL_DATA_TYPE_GLUCOSE_METER, 896, 224},
150 {BTIF_HL_DATA_TYPE_STEP_COUNTER, 6624, 224},
151 {BTIF_HL_DATA_TYPE_BCA, 7730, 1230},
152 {BTIF_HL_DATA_TYPE_PEAK_FLOW , 2030, 224},
153 {BTIF_HL_DATA_TYPE_ACTIVITY_HUB, 5120, 224},
154 {BTIF_HL_DATA_TYPE_AMM, 1024, 64}
157 #define BTIF_HL_DATA_TABLE_SIZE (sizeof(data_type_table) / sizeof(btif_hl_data_type_cfg_t))
158 #define BTIF_HL_DEFAULT_SRC_TX_APDU_SIZE 10240 /* use this size if the data type is not
159 defined in the table; for future proof */
160 #define BTIF_HL_DEFAULT_SRC_RX_APDU_SIZE 512 /* use this size if the data type is not
161 defined in the table; for future proof */
163 #define BTIF_HL_ECHO_MAX_TX_RX_APDU_SIZE 1024
165 /************************************************************************************
166 ** Static utility functions
167 ************************************************************************************/
169 #define BTIF_IF_GET_NAME 16
170 void btif_hl_display_calling_process_name(void)
173 prctl(BTIF_IF_GET_NAME, name, 0, 0, 0);
174 BTIF_TRACE_DEBUG("Process name (%s)", name);
176 #define BTIF_TIMEOUT_CCH_NO_DCH_SECS 30
177 /*******************************************************************************
179 ** Function btif_hl_if_channel_setup_pending
181 ** Description check whether channel id is in setup pending state or not
185 *******************************************************************************/
186 BOOLEAN btif_hl_if_channel_setup_pending(int channel_id, UINT8 *p_app_idx, UINT8 *p_mcl_idx)
188 btif_hl_app_cb_t *p_acb;
189 btif_hl_mcl_cb_t *p_mcb;
195 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
197 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
200 for (j=0; j< BTA_HL_NUM_MCLS; j++)
202 p_mcb = BTIF_HL_GET_MCL_CB_PTR(i, j);
204 p_mcb->is_connected && p_mcb->pcb.channel_id == channel_id )
216 BTIF_TRACE_DEBUG("%s found=%d channel_id=0x%08x",
217 __FUNCTION__, found, channel_id, *p_app_idx, *p_mcl_idx);
221 /*******************************************************************************
223 ** Function btif_hl_num_dchs_in_use
225 ** Description find number of DCHs in use
228 *******************************************************************************/
229 UINT8 btif_hl_num_dchs_in_use(UINT8 mcl_handle){
231 btif_hl_app_cb_t * p_acb;
232 btif_hl_mcl_cb_t *p_mcb;
236 for (i=0; i<BTA_HL_NUM_APPS; i++)
238 BTIF_TRACE_DEBUG("btif_hl_num_dchs:i = %d",i);
239 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
240 if (p_acb && p_acb->in_use)
242 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
244 if(p_acb->mcb[j].in_use)
245 BTIF_TRACE_DEBUG("btif_hl_num_dchs:mcb in use j=%d, mcl_handle=%d,mcb handle=%d",
246 j,mcl_handle, p_acb->mcb[j].mcl_handle);
247 if (p_acb->mcb[j].in_use &&
248 (p_acb->mcb[j].mcl_handle == mcl_handle))
250 p_mcb = &p_acb->mcb[j];
251 BTIF_TRACE_DEBUG("btif_hl_num_dchs: mcl handle found j =%d",j);
252 for (x=0; x < BTA_HL_NUM_MDLS_PER_MCL ; x ++)
254 if (p_mcb->mdl[x].in_use)
256 BTIF_TRACE_DEBUG("btif_hl_num_dchs_in_use:found x =%d",x);
265 BTIF_TRACE_DEBUG("%s dch in use count=%d", __FUNCTION__, cnt);
268 /*******************************************************************************
270 ** Function btif_hl_tmr_hdlr
272 ** Description Process timer timeout
275 *******************************************************************************/
276 void btif_hl_tmr_hdlr(TIMER_LIST_ENT *tle)
278 btif_hl_mcl_cb_t *p_mcb;
280 BTIF_TRACE_DEBUG("%s timer_in_use=%d", __FUNCTION__, tle->in_use );
282 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
284 for (j=0; j< BTA_HL_NUM_MCLS; j++)
286 p_mcb =BTIF_HL_GET_MCL_CB_PTR(i,j);
288 if (p_mcb->cch_timer_active)
290 BTIF_TRACE_DEBUG("%app_idx=%d, mcl_idx=%d mcl-connected=%d",
291 i, j, p_mcb->is_connected);
292 p_mcb->cch_timer_active = FALSE;
293 if (p_mcb->is_connected)
295 BTIF_TRACE_DEBUG("Idle timeout Close CCH app_idx=%d mcl_idx=%d mcl_handle=%d",
296 i ,j, p_mcb->mcl_handle);
297 BTA_HlCchClose(p_mcb->mcl_handle);
301 BTIF_TRACE_DEBUG("CCH idle timeout But CCH not connected app_idx=%d mcl_idx=%d ",i,j);
307 /*******************************************************************************
309 ** Function btif_hl_stop_cch_timer
311 ** Description stop CCH timer
314 *******************************************************************************/
315 void btif_hl_stop_cch_timer(UINT8 app_idx, UINT8 mcl_idx)
317 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
318 BTIF_TRACE_DEBUG("%s app_idx=%d, mcl_idx=%d timer_in_use=%d",
319 __FUNCTION__,app_idx, mcl_idx, p_mcb->cch_timer.in_use);
321 p_mcb->cch_timer_active = FALSE;
322 if (p_mcb->cch_timer.in_use)
324 BTIF_TRACE_DEBUG("stop CCH timer ");
325 btu_stop_timer(&p_mcb->cch_timer);
328 /*******************************************************************************
330 ** Function btif_hl_start_cch_timer
332 ** Description start CCH timer
335 *******************************************************************************/
336 void btif_hl_start_cch_timer(UINT8 app_idx, UINT8 mcl_idx)
338 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
339 BTIF_TRACE_DEBUG("%s app_idx=%d, mcl_idx=%d timer_active=%d timer_in_use=%d",
340 __FUNCTION__,app_idx, mcl_idx,
341 p_mcb->cch_timer_active, p_mcb->cch_timer.in_use);
343 p_mcb->cch_timer_active = TRUE;
344 if (!p_mcb->cch_timer.in_use)
346 BTIF_TRACE_DEBUG("Start CCH timer ");
347 memset(&p_mcb->cch_timer, 0, sizeof(TIMER_LIST_ENT));
348 p_mcb->cch_timer.param = (UINT32)btif_hl_tmr_hdlr;
349 btu_start_timer(&p_mcb->cch_timer, BTU_TTYPE_USER_FUNC,
350 BTIF_TIMEOUT_CCH_NO_DCH_SECS);
354 BTIF_TRACE_DEBUG("Restart CCH timer ");
355 btu_stop_timer(&p_mcb->cch_timer);
356 btu_start_timer(&p_mcb->cch_timer, BTU_TTYPE_USER_FUNC,
357 BTIF_TIMEOUT_CCH_NO_DCH_SECS);
361 /*******************************************************************************
363 ** Function btif_hl_find_mdl_idx
365 ** Description Find the MDL index using MDL ID
369 *******************************************************************************/
370 static BOOLEAN btif_hl_find_mdl_idx(UINT8 app_idx, UINT8 mcl_idx, UINT16 mdl_id,
373 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
377 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
379 if (p_mcb->mdl[i].in_use &&
381 (p_mcb->mdl[i].mdl_id== mdl_id))
389 BTIF_TRACE_DEBUG("%s found=%d mdl_id=%d mdl_idx=%d ",
390 __FUNCTION__,found, mdl_id, i);
395 /*******************************************************************************
397 ** Function btif_hl_get_buf
399 ** Description get buffer
403 *******************************************************************************/
404 void * btif_hl_get_buf(UINT16 size)
408 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
409 BTIF_TRACE_DEBUG("ret size=%d GKI_MAX_BUF_SIZE=%d",size, 6000);
413 p_new = GKI_getbuf(size);
417 BTIF_TRACE_DEBUG("btif_hl_get_buf use HL large data pool");
418 p_new = GKI_getpoolbuf(4);
423 /*******************************************************************************
425 ** Function btif_hl_free_buf
427 ** Description free buffer
431 *******************************************************************************/
432 void btif_hl_free_buf(void **p)
436 BTIF_TRACE_DEBUG("%s OK", __FUNCTION__ );
441 BTIF_TRACE_ERROR("%s NULL pointer",__FUNCTION__ );
443 /*******************************************************************************
445 ** Function btif_hl_is_the_first_reliable_existed
447 ** Description This function checks whether the first reliable DCH channel
448 ** has been setup on the MCL or not
450 ** Returns BOOLEAN - TRUE exist
451 ** FALSE does not exist
453 *******************************************************************************/
454 BOOLEAN btif_hl_is_the_first_reliable_existed(UINT8 app_idx, UINT8 mcl_idx )
456 btif_hl_mcl_cb_t *p_mcb =BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
457 BOOLEAN is_existed =FALSE;
460 for (i=0; i< BTA_HL_NUM_MDLS_PER_MCL; i++)
462 if (p_mcb->mdl[i].in_use && p_mcb->mdl[i].is_the_first_reliable)
469 BTIF_TRACE_DEBUG("bta_hl_is_the_first_reliable_existed is_existed=%d ",is_existed );
472 /*******************************************************************************
474 ** Function btif_hl_clean_delete_mdl
476 ** Description Cleanup the delete mdl control block
480 *******************************************************************************/
481 static void btif_hl_clean_delete_mdl(btif_hl_delete_mdl_t *p_cb)
483 BTIF_TRACE_DEBUG("%s", __FUNCTION__ );
484 memset(p_cb, 0 , sizeof(btif_hl_delete_mdl_t));
487 /*******************************************************************************
489 ** Function btif_hl_clean_pcb
491 ** Description Cleanup the pending chan control block
495 *******************************************************************************/
496 static void btif_hl_clean_pcb(btif_hl_pending_chan_cb_t *p_pcb)
498 BTIF_TRACE_DEBUG("%s", __FUNCTION__ );
499 memset(p_pcb, 0 , sizeof(btif_hl_pending_chan_cb_t));
503 /*******************************************************************************
505 ** Function btif_hl_clean_mdl_cb
507 ** Description Cleanup the MDL control block
511 *******************************************************************************/
512 static void btif_hl_clean_mdl_cb(btif_hl_mdl_cb_t *p_dcb)
514 BTIF_TRACE_DEBUG("%s", __FUNCTION__ );
515 btif_hl_free_buf((void **) &p_dcb->p_rx_pkt);
516 btif_hl_free_buf((void **) &p_dcb->p_tx_pkt);
517 memset(p_dcb, 0 , sizeof(btif_hl_mdl_cb_t));
521 /*******************************************************************************
523 ** Function btif_hl_reset_mcb
525 ** Description Reset MCL control block
529 *******************************************************************************/
530 static void btif_hl_clean_mcl_cb(UINT8 app_idx, UINT8 mcl_idx)
532 btif_hl_mcl_cb_t *p_mcb;
533 BTIF_TRACE_DEBUG("%s app_idx=%d, mcl_idx=%d", __FUNCTION__,app_idx, mcl_idx);
534 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
535 memset(p_mcb, 0, sizeof(btif_hl_mcl_cb_t));
539 /*******************************************************************************
541 ** Function btif_hl_find_sdp_idx_using_mdep_filter
543 ** Description This function finds the SDP record index using MDEP filter parameters
547 *******************************************************************************/
548 static void btif_hl_reset_mdep_filter(UINT8 app_idx)
550 btif_hl_app_cb_t *p_acb =BTIF_HL_GET_APP_CB_PTR(app_idx);
551 p_acb->filter.num_elems = 0;
554 /*******************************************************************************
556 ** Function btif_hl_find_sdp_idx_using_mdep_filter
558 ** Description This function finds the SDP record index using MDEP filter parameters
562 *******************************************************************************/
563 static BOOLEAN btif_hl_find_sdp_idx_using_mdep_filter(UINT8 app_idx, UINT8 mcl_idx, UINT8 *p_sdp_idx)
565 btif_hl_app_cb_t *p_acb =BTIF_HL_GET_APP_CB_PTR(app_idx);
566 btif_hl_mcl_cb_t *p_mcb =BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
567 UINT8 i, j, num_recs,num_elems, num_mdeps, mdep_cnt, mdep_idx;
568 tBTA_HL_MDEP_ROLE peer_mdep_role;
570 tBTA_HL_SDP_MDEP_CFG *p_mdep;
571 BOOLEAN found = FALSE;
574 BTIF_TRACE_DEBUG("btif_hl_find_sdp_idx_using_mdep_filter");
575 num_recs = p_mcb->sdp.num_recs;
576 num_elems = p_acb->filter.num_elems;
579 BTIF_TRACE_DEBUG("btif_hl_find_sdp_idx_using_mdep_filter num_elem=0");
585 for (i=0; i<num_recs; i++)
587 num_mdeps = p_mcb->sdp.sdp_rec[i].num_mdeps;
588 for (j=0; j<num_elems; j++ )
590 data_type = p_acb->filter.elem[j].data_type;
591 peer_mdep_role = p_acb->filter.elem[j].peer_mdep_role;
595 while (!elem_found && mdep_idx < num_mdeps )
597 p_mdep = &(p_mcb->sdp.sdp_rec[i].mdep_cfg[mdep_idx]);
598 if ( (p_mdep->data_type == data_type) &&
599 (p_mdep->mdep_role == peer_mdep_role) )
622 BTIF_TRACE_DEBUG("btif_hl_find_sdp_idx_using_mdep_filter found idx=%d",i);
628 BTIF_TRACE_DEBUG("%s found=%d sdp_idx=%d",__FUNCTION__ , found, *p_sdp_idx);
630 btif_hl_reset_mdep_filter(app_idx);
634 /*******************************************************************************
636 ** Function btif_hl_is_reconnect_possible
638 ** Description check reconnect is possible or not
642 *******************************************************************************/
643 BOOLEAN btif_hl_is_reconnect_possible(UINT8 app_idx, UINT8 mcl_idx, int mdep_cfg_idx,
644 tBTA_HL_DCH_OPEN_PARAM *p_dch_open_api, tBTA_HL_MDL_ID *p_mdl_id)
646 btif_hl_app_cb_t *p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
647 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
648 tBTA_HL_DCH_CFG local_cfg = p_dch_open_api->local_cfg;
649 tBTA_HL_DCH_MODE dch_mode = BTA_HL_DCH_MODE_RELIABLE;
650 BOOLEAN use_mdl_dch_mode=FALSE;
651 btif_hl_mdl_cfg_t *p_mdl;
652 btif_hl_mdl_cfg_t *p_mdl1;
654 BOOLEAN is_reconnect_ok=FALSE;
655 BOOLEAN stream_mode_avail=FALSE;
656 UINT16 data_type = p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg.data_cfg[0].data_type;
657 tBTA_HL_MDEP_ID peer_mdep_id = p_dch_open_api->peer_mdep_id;
661 BTIF_TRACE_DEBUG("%s app_idx=%d mcl_idx=%d mdep_cfg_idx=%d",
662 __FUNCTION__, app_idx, mcl_idx, mdep_cfg_idx );
665 case BTA_HL_DCH_CFG_NO_PREF:
666 if (!btif_hl_is_the_first_reliable_existed(app_idx, mcl_idx))
668 dch_mode = BTA_HL_DCH_MODE_RELIABLE;
672 use_mdl_dch_mode = TRUE;
675 case BTA_HL_DCH_CFG_RELIABLE:
676 dch_mode = BTA_HL_DCH_MODE_RELIABLE;
678 case BTA_HL_DCH_CFG_STREAMING:
679 dch_mode = BTA_HL_DCH_MODE_STREAMING;
682 BTIF_TRACE_ERROR("Invalid local_cfg=%d",local_cfg );
683 return is_reconnect_ok;
688 BTIF_TRACE_DEBUG("local_cfg=%d use_mdl_dch_mode=%d dch_mode=%d ",
689 local_cfg, use_mdl_dch_mode, dch_mode );
691 for (i=0, p_mdl=&p_acb->mdl_cfg[0] ; i< BTA_HL_NUM_MDL_CFGS; i++, p_mdl++ )
693 if (p_mdl->base.active &&
694 p_mdl->extra.data_type ==data_type &&
695 (p_mdl->extra.peer_mdep_id != BTA_HL_INVALID_MDEP_ID && p_mdl->extra.peer_mdep_id == peer_mdep_id) &&
696 memcpy(p_mdl->base.peer_bd_addr, p_mcb->bd_addr,sizeof(BD_ADDR) ) &&
697 p_mdl->base.mdl_id &&
698 !btif_hl_find_mdl_idx(app_idx, mcl_idx,p_mdl->base.mdl_id, &mdl_idx))
700 BTIF_TRACE_DEBUG("i=%d Matched active=%d mdl_id =%d, mdl_dch_mode=%d",
701 i, p_mdl->base.active, p_mdl->base.mdl_id,p_mdl->base.dch_mode);
702 if (!use_mdl_dch_mode)
704 if (p_mdl->base.dch_mode == dch_mode)
706 is_reconnect_ok = TRUE;
707 *p_mdl_id = p_mdl->base.mdl_id;
708 BTIF_TRACE_DEBUG("reconnect is possible dch_mode=%d mdl_id=%d", dch_mode, p_mdl->base.mdl_id );
714 is_reconnect_ok = TRUE;
715 for (j=i, p_mdl1=&p_acb->mdl_cfg[i]; j< BTA_HL_NUM_MDL_CFGS; j++, p_mdl1++)
717 if (p_mdl1->base.active &&
718 p_mdl1->extra.data_type == data_type &&
719 (p_mdl1->extra.peer_mdep_id != BTA_HL_INVALID_MDEP_ID && p_mdl1->extra.peer_mdep_id == peer_mdep_id) &&
720 memcpy(p_mdl1->base.peer_bd_addr, p_mcb->bd_addr,sizeof(BD_ADDR)) &&
721 p_mdl1->base.dch_mode == BTA_HL_DCH_MODE_STREAMING)
723 stream_mode_avail = TRUE;
724 BTIF_TRACE_DEBUG("found streaming mode mdl index=%d", j);
729 if (stream_mode_avail)
731 dch_mode = BTA_HL_DCH_MODE_STREAMING;
732 *p_mdl_id = p_mdl1->base.mdl_id;
733 BTIF_TRACE_DEBUG("reconnect is ok index=%d dch_mode=streaming mdl_id=%d", j, *p_mdl_id);
738 dch_mode= p_mdl->base.dch_mode;
739 *p_mdl_id = p_mdl->base.mdl_id;
740 BTIF_TRACE_DEBUG("reconnect is ok index=%d dch_mode=%d mdl_id=%d", i, p_mdl->base.dch_mode, *p_mdl_id);
750 BTIF_TRACE_DEBUG("is_reconnect_ok dch_mode=%d mdl_id=%d",is_reconnect_ok, dch_mode, *p_mdl_id);
751 return is_reconnect_ok;
754 /*******************************************************************************
756 ** Function btif_hl_dch_open
758 ** Description Process DCH open request using the DCH Open API parameters
762 *******************************************************************************/
763 BOOLEAN btif_hl_dch_open(UINT8 app_id, BD_ADDR bd_addr,
764 tBTA_HL_DCH_OPEN_PARAM *p_dch_open_api,
766 btif_hl_pend_dch_op_t op, int *channel_id){
767 btif_hl_app_cb_t *p_acb;
768 btif_hl_mcl_cb_t *p_mcb;
769 btif_hl_pending_chan_cb_t *p_pcb;
770 UINT8 app_idx, mcl_idx;
771 BOOLEAN status = FALSE;
772 tBTA_HL_MDL_ID mdl_id;
773 tBTA_HL_DCH_RECONNECT_PARAM reconnect_param;
775 BTIF_TRACE_DEBUG("%s app_id=%d ",
776 __FUNCTION__, app_id );
777 BTIF_TRACE_DEBUG("DB [%02x:%02x:%02x:%02x:%02x:%02x]",
778 bd_addr[0], bd_addr[1],bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5]);
780 if (btif_hl_find_app_idx(app_id, &app_idx))
782 if (btif_hl_find_mcl_idx(app_idx, bd_addr , &mcl_idx))
784 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
786 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
789 p_mcb->req_ctrl_psm = p_dch_open_api->ctrl_psm;
791 p_pcb->in_use = TRUE;
793 p_pcb->channel_id = (int) btif_hl_get_next_channel_id(app_id);
794 p_pcb->cb_state = BTIF_HL_CHAN_CB_STATE_CONNECTING_PENDING;
795 p_pcb->mdep_cfg_idx = mdep_cfg_idx;
796 memcpy(p_pcb->bd_addr, bd_addr, sizeof(BD_ADDR));
799 if (p_mcb->sdp.num_recs)
801 if (p_mcb->valid_sdp_idx)
803 p_dch_open_api->ctrl_psm = p_mcb->ctrl_psm;
806 if (!btif_hl_is_reconnect_possible(app_idx, mcl_idx, mdep_cfg_idx, p_dch_open_api, &mdl_id ))
809 BTIF_TRACE_DEBUG("Issue DCH open" );
810 BTA_HlDchOpen(p_mcb->mcl_handle, p_dch_open_api);
814 reconnect_param.ctrl_psm = p_mcb->ctrl_psm;
815 reconnect_param.mdl_id = mdl_id;;
816 BTIF_TRACE_DEBUG("Issue Reconnect ctrl_psm=0x%x mdl_id=0x%x",reconnect_param.ctrl_psm, reconnect_param.mdl_id );
817 BTA_HlDchReconnect(p_mcb->mcl_handle, &reconnect_param);
824 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
825 p_mcb->cch_oper = BTIF_HL_CCH_OP_DCH_OPEN;
826 BTA_HlSdpQuery(app_id,p_acb->app_handle, bd_addr);
833 BTIF_TRACE_DEBUG("status=%d ", status);
836 /*******************************************************************************
838 ** Function btif_hl_copy_bda
840 ** Description copy bt_bdaddr_t to BD_ADDR format
844 *******************************************************************************/
845 void btif_hl_copy_bda(bt_bdaddr_t *bd_addr, BD_ADDR bda){
849 bd_addr->address[i] = bda[i] ;
852 /*******************************************************************************
854 ** Function btif_hl_copy_bda
856 ** Description display bt_bdaddr_t
860 *******************************************************************************/
861 void btif_hl_display_bt_bda(bt_bdaddr_t *bd_addr){
862 BTIF_TRACE_DEBUG("DB [%02x:%02x:%02x:%02x:%02x:%02x]",
863 bd_addr->address[0], bd_addr->address[1], bd_addr->address[2],
864 bd_addr->address[3], bd_addr->address[4], bd_addr->address[5]);
867 /*******************************************************************************
869 ** Function btif_hl_dch_abort
871 ** Description Process DCH abort request
875 *******************************************************************************/
876 void btif_hl_dch_abort(UINT8 app_idx, UINT8 mcl_idx){
877 btif_hl_mcl_cb_t *p_mcb;
879 BTIF_TRACE_DEBUG("%s app_idx=%d mcl_idx=%d",__FUNCTION__, app_idx, mcl_idx );
880 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
881 if (p_mcb->is_connected)
883 BTA_HlDchAbort(p_mcb->mcl_handle);
887 p_mcb->pcb.abort_pending = TRUE;
891 /*******************************************************************************
893 ** Function btif_hl_cch_open
895 ** Description Process CCH open request
899 *******************************************************************************/
900 BOOLEAN btif_hl_cch_open(UINT8 app_id, BD_ADDR bd_addr, UINT16 ctrl_psm,
902 btif_hl_pend_dch_op_t op, int *channel_id){
904 btif_hl_app_cb_t *p_acb;
905 btif_hl_mcl_cb_t *p_mcb;
906 btif_hl_pending_chan_cb_t *p_pcb;
907 UINT8 app_idx, mcl_idx, chan_idx;
908 BOOLEAN status = TRUE;
910 BTIF_TRACE_DEBUG("%s app_id=%d ctrl_psm=%d mdep_cfg_idx=%d op=%d",
911 __FUNCTION__, app_id, ctrl_psm, mdep_cfg_idx, op);
912 BTIF_TRACE_DEBUG("DB [%02x:%02x:%02x:%02x:%02x:%02x]",
913 bd_addr[0], bd_addr[1],bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5]);
915 if (btif_hl_find_app_idx(app_id, &app_idx))
917 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
919 if (!btif_hl_find_mcl_idx(app_idx, bd_addr, &mcl_idx))
921 if (btif_hl_find_avail_mcl_idx(app_idx, &mcl_idx))
923 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
924 memset(p_mcb,0, sizeof(btif_hl_mcl_cb_t));
925 p_mcb->in_use = TRUE;
926 bdcpy(p_mcb->bd_addr, bd_addr);
930 p_mcb->cch_oper = BTIF_HL_CCH_OP_MDEP_FILTERING;
934 p_mcb->cch_oper = BTIF_HL_CCH_OP_MATCHED_CTRL_PSM;
935 p_mcb->req_ctrl_psm = ctrl_psm;
938 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
939 p_pcb->in_use = TRUE;
940 p_pcb->mdep_cfg_idx = mdep_cfg_idx;
941 memcpy(p_pcb->bd_addr, bd_addr, sizeof(BD_ADDR));
946 case BTIF_HL_PEND_DCH_OP_OPEN:
948 p_pcb->channel_id = (int) btif_hl_get_next_channel_id(app_id);
949 p_pcb->cb_state = BTIF_HL_CHAN_CB_STATE_CONNECTING_PENDING;
951 case BTIF_HL_PEND_DCH_OP_DELETE_MDL:
952 p_pcb->channel_id = p_acb->delete_mdl.channel_id;
953 p_pcb->cb_state = BTIF_HL_CHAN_CB_STATE_DESTROYED_PENDING;
958 BTA_HlSdpQuery(app_id,p_acb->app_handle, bd_addr);
963 BTIF_TRACE_ERROR("Open CCH request discarded- No mcl cb");
969 BTIF_TRACE_ERROR("Open CCH request discarded- already in USE");
975 BTIF_TRACE_ERROR("Invalid app_id=%d", app_id);
980 BTIF_TRACE_DEBUG("status=%d channel_id=0x%08x", status, *channel_id);
984 BTIF_TRACE_DEBUG("status=%d ", status);
990 /*******************************************************************************
992 ** Function btif_hl_find_mdl_idx_using_handle
994 ** Description Find the MDL index using channel id
998 *******************************************************************************/
999 BOOLEAN btif_hl_find_mdl_cfg_idx_using_channel_id(int channel_id,
1001 UINT8 *p_mdl_cfg_idx){
1002 btif_hl_app_cb_t *p_acb;
1003 btif_hl_mdl_cfg_t *p_mdl;
1004 BOOLEAN found=FALSE;
1006 int mdl_cfg_channel_id;
1010 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1012 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
1013 for (j=0; j< BTA_HL_NUM_MDL_CFGS; j++)
1015 p_mdl =BTIF_HL_GET_MDL_CFG_PTR(i,j);
1016 mdl_cfg_channel_id = *(BTIF_HL_GET_MDL_CFG_CHANNEL_ID_PTR(i,j));
1017 if (p_acb->in_use &&
1018 p_mdl->base.active &&
1019 (mdl_cfg_channel_id == channel_id))
1029 BTIF_TRACE_EVENT("%s found=%d channel_id=0x%08x, app_idx=%d mdl_cfg_idx=%d ",
1030 __FUNCTION__,found,channel_id, i,j );
1033 /*******************************************************************************
1035 ** Function btif_hl_find_mdl_idx_using_handle
1037 ** Description Find the MDL index using channel id
1041 *******************************************************************************/
1042 BOOLEAN btif_hl_find_mdl_idx_using_channel_id(int channel_id,
1043 UINT8 *p_app_idx,UINT8 *p_mcl_idx,
1045 btif_hl_app_cb_t *p_acb;
1046 btif_hl_mcl_cb_t *p_mcb;
1047 btif_hl_mdl_cb_t *p_dcb;
1048 BOOLEAN found=FALSE;
1051 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1053 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
1054 for (j=0; j< BTA_HL_NUM_MCLS; j++)
1056 p_mcb =BTIF_HL_GET_MCL_CB_PTR(i,j);
1057 for (k=0; k< BTA_HL_NUM_MDLS_PER_MCL; k++)
1059 p_dcb =BTIF_HL_GET_MDL_CB_PTR(i,j,k);
1060 if (p_acb->in_use &&
1063 (p_dcb->channel_id == channel_id))
1074 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d mcl_idx=%d mdl_idx=%d ",
1075 __FUNCTION__,found,i,j,k );
1079 /*******************************************************************************
1081 ** Function btif_hl_find_channel_id_using_mdl_id
1083 ** Description Find channel id using mdl_id'
1086 *********************************************************************************/
1087 BOOLEAN btif_hl_find_channel_id_using_mdl_id(UINT8 app_idx, tBTA_HL_MDL_ID mdl_id,
1089 btif_hl_app_cb_t *p_acb;
1090 btif_hl_mdl_cfg_t *p_mdl;
1091 BOOLEAN found=FALSE;
1093 int mdl_cfg_channel_id;
1094 p_acb =BTIF_HL_GET_APP_CB_PTR(app_idx);
1095 if (p_acb && p_acb->in_use)
1097 for (j=0; j< BTA_HL_NUM_MDL_CFGS; j++)
1099 p_mdl =BTIF_HL_GET_MDL_CFG_PTR(app_idx,j);
1100 mdl_cfg_channel_id = *(BTIF_HL_GET_MDL_CFG_CHANNEL_ID_PTR(app_idx,j));
1101 if ( p_mdl->base.active && (p_mdl->base.mdl_id == mdl_id))
1104 *p_channel_id = mdl_cfg_channel_id;
1109 BTIF_TRACE_EVENT("%s found=%d channel_id=0x%08x, mdl_id=0x%x app_idx=%d mdl_cfg_idx=%d ",
1110 __FUNCTION__,found,*p_channel_id,mdl_id, app_idx,j );
1115 /*******************************************************************************
1117 ** Function btif_hl_find_mdl_idx_using_handle
1119 ** Description Find the MDL index using handle
1123 *******************************************************************************/
1124 BOOLEAN btif_hl_find_mdl_idx_using_handle(tBTA_HL_MDL_HANDLE mdl_handle,
1125 UINT8 *p_app_idx,UINT8 *p_mcl_idx,
1127 btif_hl_app_cb_t *p_acb;
1128 btif_hl_mcl_cb_t *p_mcb;
1129 btif_hl_mdl_cb_t *p_dcb;
1130 BOOLEAN found=FALSE;
1136 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1138 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
1139 for (j=0; j< BTA_HL_NUM_MCLS; j++)
1141 p_mcb =BTIF_HL_GET_MCL_CB_PTR(i,j);
1142 for (k=0; k< BTA_HL_NUM_MDLS_PER_MCL; k++)
1144 p_dcb =BTIF_HL_GET_MDL_CB_PTR(i,j,k);
1145 if (p_acb->in_use &&
1148 (p_dcb->mdl_handle == mdl_handle))
1161 BTIF_TRACE_EVENT("%s found=%d app_idx=%d mcl_idx=%d mdl_idx=%d ",
1162 __FUNCTION__,found,i,j,k );
1165 /*******************************************************************************
1167 ** Function btif_hl_find_peer_mdep_id
1169 ** Description Find the peer MDEP ID from the received SPD records
1173 *******************************************************************************/
1174 static BOOLEAN btif_hl_find_peer_mdep_id(UINT8 app_id, BD_ADDR bd_addr,
1175 tBTA_HL_MDEP_ROLE local_mdep_role,
1177 tBTA_HL_MDEP_ID *p_peer_mdep_id){
1178 UINT8 app_idx, mcl_idx;
1179 btif_hl_app_cb_t *p_acb;
1180 btif_hl_mcl_cb_t *p_mcb;
1181 tBTA_HL_SDP_REC *p_rec;
1183 BOOLEAN found = FALSE;
1184 tBTA_HL_MDEP_ROLE peer_mdep_role;
1187 BTIF_TRACE_DEBUG("%s app_id=%d local_mdep_role=%d, data_type=%d",
1188 __FUNCTION__, app_id, local_mdep_role, data_type);
1190 BTIF_TRACE_DEBUG("DB [%02x:%02x:%02x:%02x:%02x:%02x]",
1191 bd_addr[0], bd_addr[1],
1192 bd_addr[2], bd_addr[3],
1193 bd_addr[4], bd_addr[5]);
1196 BTIF_TRACE_DEBUG("local_mdep_role=%d", local_mdep_role);
1197 BTIF_TRACE_DEBUG("data_type=%d", data_type);
1199 if (local_mdep_role == BTA_HL_MDEP_ROLE_SINK)
1200 peer_mdep_role = BTA_HL_MDEP_ROLE_SOURCE;
1202 peer_mdep_role = BTA_HL_MDEP_ROLE_SINK;
1204 if (btif_hl_find_app_idx(app_id, &app_idx) )
1206 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
1207 if (btif_hl_find_mcl_idx(app_idx, bd_addr, &mcl_idx))
1209 p_mcb =BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1211 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d",app_idx, mcl_idx);
1212 BTIF_TRACE_DEBUG("valid_spd_idx=%d sdp_idx=%d",p_mcb->valid_sdp_idx, p_mcb->sdp_idx);
1213 if (p_mcb->valid_sdp_idx)
1215 p_rec = &p_mcb->sdp.sdp_rec[p_mcb->sdp_idx];
1216 num_mdeps = p_rec->num_mdeps;
1217 BTIF_TRACE_DEBUG("num_mdeps=%d", num_mdeps);
1219 for (i=0; i< num_mdeps; i++)
1221 BTIF_TRACE_DEBUG("p_rec->mdep_cfg[%d].mdep_role=%d",i, p_rec->mdep_cfg[i].mdep_role);
1222 BTIF_TRACE_DEBUG("p_rec->mdep_cfg[%d].data_type =%d",i, p_rec->mdep_cfg[i].data_type );
1223 if ((p_rec->mdep_cfg[i].mdep_role == peer_mdep_role) &&
1224 (p_rec->mdep_cfg[i].data_type == data_type))
1227 *p_peer_mdep_id = p_rec->mdep_cfg[i].mdep_id;
1235 BTIF_TRACE_DEBUG("found =%d *p_peer_mdep_id=%d", found, *p_peer_mdep_id);
1240 /*******************************************************************************
1242 ** Function btif_hl_find_mdep_cfg_idx
1244 ** Description Find the MDEP configuration index using local MDEP_ID
1248 *******************************************************************************/
1249 static BOOLEAN btif_hl_find_mdep_cfg_idx(UINT8 app_idx, tBTA_HL_MDEP_ID local_mdep_id,
1250 UINT8 *p_mdep_cfg_idx){
1251 btif_hl_app_cb_t *p_acb =BTIF_HL_GET_APP_CB_PTR(app_idx);
1252 tBTA_HL_SUP_FEATURE *p_sup_feature= &p_acb->sup_feature;
1253 BOOLEAN found =FALSE;
1256 for (i=0; i< p_sup_feature->num_of_mdeps; i++)
1258 BTIF_TRACE_DEBUG("btif_hl_find_mdep_cfg_idx: mdep_id=%d app_idx = %d",
1259 p_sup_feature->mdep[i].mdep_id,app_idx);
1260 if ( p_sup_feature->mdep[i].mdep_id == local_mdep_id)
1263 *p_mdep_cfg_idx = i;
1268 BTIF_TRACE_DEBUG("%s found=%d mdep_idx=%d local_mdep_id=%d app_idx=%d ",
1269 __FUNCTION__, found,i, local_mdep_id,app_idx);
1275 /*******************************************************************************
1277 ** Function btif_hl_find_mcl_idx
1279 ** Description Find the MCL index using BD address
1283 *******************************************************************************/
1284 BOOLEAN btif_hl_find_mcl_idx(UINT8 app_idx, BD_ADDR p_bd_addr, UINT8 *p_mcl_idx){
1285 BOOLEAN found=FALSE;
1287 btif_hl_app_cb_t *p_acb =BTIF_HL_GET_APP_CB_PTR(app_idx);
1288 btif_hl_mcl_cb_t *p_mcb;
1291 for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
1293 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, i);
1294 if (p_mcb->in_use &&
1295 (!memcmp (p_mcb->bd_addr, p_bd_addr, BD_ADDR_LEN)))
1304 BTIF_TRACE_DEBUG("%s found=%d idx=%d",__FUNCTION__, found, i);
1307 /*******************************************************************************
1309 ** Function btif_hl_init
1311 ** Description HL initialization function.
1315 *******************************************************************************/
1316 static void btif_hl_init(void){
1317 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
1318 memset(p_btif_hl_cb, 0, sizeof(btif_hl_cb_t));
1319 btif_hl_init_next_app_id();
1320 btif_hl_init_next_channel_id();
1322 /*******************************************************************************
1324 ** Function btif_hl_disable
1326 ** Description Disable initialization function.
1330 *******************************************************************************/
1331 static void btif_hl_disable(void){
1332 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
1334 if ((p_btif_hl_cb->state != BTIF_HL_STATE_DISABLING) &&
1335 (p_btif_hl_cb->state != BTIF_HL_STATE_DISABLED))
1337 btif_hl_set_state(BTIF_HL_STATE_DISABLING);
1341 /*******************************************************************************
1343 ** Function btif_hl_is_no_active_app
1345 ** Description Find whether or not any APP is still in use
1349 *******************************************************************************/
1350 static BOOLEAN btif_hl_is_no_active_app(void){
1351 BOOLEAN no_active_app = TRUE;
1354 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1356 if (btif_hl_cb.acb[i].in_use)
1358 no_active_app = FALSE;
1363 BTIF_TRACE_DEBUG("%s no_active_app=%d ", __FUNCTION__, no_active_app );
1364 return no_active_app;
1367 /*******************************************************************************
1369 ** Function btif_hl_free_app_idx
1371 ** Description free an application control block
1375 *******************************************************************************/
1376 static void btif_hl_free_app_idx(UINT8 app_idx){
1378 if ((app_idx < BTA_HL_NUM_APPS) && btif_hl_cb.acb[app_idx].in_use )
1380 btif_hl_cb.acb[app_idx].in_use = FALSE;
1381 memset (&btif_hl_cb.acb[app_idx], 0, sizeof(btif_hl_app_cb_t));
1384 /*******************************************************************************
1386 ** Function btif_hl_set_state
1388 ** Description set HL state
1392 *******************************************************************************/
1393 static void btif_hl_set_state(btif_hl_state_t state){
1394 BTIF_TRACE_DEBUG("btif_hl_set_state: %d ---> %d ", p_btif_hl_cb->state, state);
1395 p_btif_hl_cb->state = state;
1398 /*******************************************************************************
1400 ** Function btif_hl_set_state
1402 ** Description get HL state
1404 ** Returns btif_hl_state_t
1406 *******************************************************************************/
1408 static btif_hl_state_t btif_hl_get_state(void){
1409 BTIF_TRACE_DEBUG("btif_hl_get_state: %d ", p_btif_hl_cb->state);
1410 return p_btif_hl_cb->state;
1413 /*******************************************************************************
1415 ** Function btif_hl_find_data_type_idx
1417 ** Description Find the index in the data type table
1421 *******************************************************************************/
1422 static BOOLEAN btif_hl_find_data_type_idx(UINT16 data_type, UINT8 *p_idx){
1423 BOOLEAN found = FALSE;
1426 for (i=0; i< BTIF_HL_DATA_TABLE_SIZE; i++ )
1428 if (data_type_table[i].data_type == data_type)
1436 BTIF_TRACE_DEBUG("%s found=%d, data_type=0x%x idx=%d", __FUNCTION__, found, data_type, i);
1440 /*******************************************************************************
1442 ** Function btif_hl_get_max_tx_apdu_size
1444 ** Description Find the maximum TX APDU size for the specified data type and
1449 *******************************************************************************/
1450 UINT16 btif_hl_get_max_tx_apdu_size(tBTA_HL_MDEP_ROLE mdep_role,
1453 UINT16 max_tx_apdu_size =0;
1455 if (btif_hl_find_data_type_idx(data_type, &idx))
1457 if (mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
1459 max_tx_apdu_size = data_type_table[idx].max_tx_apdu_size;
1463 max_tx_apdu_size = data_type_table[idx].max_rx_apdu_size;
1468 if (mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
1470 max_tx_apdu_size = BTIF_HL_DEFAULT_SRC_TX_APDU_SIZE;
1474 max_tx_apdu_size = BTIF_HL_DEFAULT_SRC_RX_APDU_SIZE;
1480 BTIF_TRACE_DEBUG("%s mdep_role=%d data_type=0x%4x size=%d",
1481 __FUNCTION__, mdep_role, data_type, max_tx_apdu_size);
1482 return max_tx_apdu_size;
1486 /*******************************************************************************
1488 ** Function btif_hl_get_max_rx_apdu_size
1490 ** Description Find the maximum RX APDU size for the specified data type and
1495 *******************************************************************************/
1496 UINT16 btif_hl_get_max_rx_apdu_size(tBTA_HL_MDEP_ROLE mdep_role,
1499 UINT16 max_rx_apdu_size =0;
1501 if (btif_hl_find_data_type_idx(data_type, &idx))
1503 if (mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
1505 max_rx_apdu_size = data_type_table[idx].max_rx_apdu_size;
1509 max_rx_apdu_size = data_type_table[idx].max_tx_apdu_size;
1514 if (mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
1516 max_rx_apdu_size = BTIF_HL_DEFAULT_SRC_RX_APDU_SIZE;
1520 max_rx_apdu_size = BTIF_HL_DEFAULT_SRC_TX_APDU_SIZE;
1525 BTIF_TRACE_DEBUG("%s mdep_role=%d data_type=0x%4x size=%d",
1526 __FUNCTION__, mdep_role, data_type, max_rx_apdu_size);
1528 return max_rx_apdu_size;
1531 /*******************************************************************************
1533 ** Function btif_hl_if_channel_setup_pending
1539 *******************************************************************************/
1541 static BOOLEAN btif_hl_get_bta_mdep_role(bthl_mdep_role_t mdep, tBTA_HL_MDEP_ROLE *p){
1542 BOOLEAN status = TRUE;
1545 case BTHL_MDEP_ROLE_SOURCE:
1546 *p = BTA_HL_MDEP_ROLE_SOURCE;
1548 case BTHL_MDEP_ROLE_SINK:
1549 *p = BTA_HL_MDEP_ROLE_SINK;
1552 *p = BTA_HL_MDEP_ROLE_SOURCE;
1557 BTIF_TRACE_DEBUG("%s status=%d bta_mdep_role=%d (%d:btif)",
1558 __FUNCTION__, status, *p, mdep);
1561 /*******************************************************************************
1563 ** Function btif_hl_get_bta_channel_type
1565 ** Description convert bthl channel type to BTA DCH channel type
1569 *******************************************************************************/
1571 static BOOLEAN btif_hl_get_bta_channel_type(bthl_channel_type_t channel_type, tBTA_HL_DCH_CFG *p){
1572 BOOLEAN status = TRUE;
1573 switch (channel_type)
1575 case BTHL_CHANNEL_TYPE_RELIABLE:
1576 *p = BTA_HL_DCH_CFG_RELIABLE;
1578 case BTHL_CHANNEL_TYPE_STREAMING:
1579 *p = BTA_HL_DCH_CFG_STREAMING;
1581 case BTHL_CHANNEL_TYPE_ANY:
1582 *p = BTA_HL_DCH_CFG_NO_PREF;
1588 BTIF_TRACE_DEBUG("%s status = %d BTA DCH CFG=%d (1-rel 2-strm",
1589 __FUNCTION__, status, *p);
1592 /*******************************************************************************
1594 ** Function btif_hl_get_next_app_id
1596 ** Description get next applcation id
1600 *******************************************************************************/
1602 static UINT8 btif_hl_get_next_app_id(){
1603 UINT8 next_app_id = btif_hl_cb.next_app_id;
1605 btif_hl_cb.next_app_id++;
1608 /*******************************************************************************
1610 ** Function btif_hl_get_next_channel_id
1612 ** Description get next channel id
1616 *******************************************************************************/
1617 static int btif_hl_get_next_channel_id(UINT8 app_id){
1618 UINT16 next_channel_id = btif_hl_cb.next_channel_id;
1620 btif_hl_cb.next_channel_id++;
1621 channel_id = (app_id << 16) + next_channel_id;
1622 BTIF_TRACE_DEBUG("%s channel_id=0x%08x, app_id=0x%02x next_channel_id=0x%04x", __FUNCTION__,
1623 channel_id, app_id, next_channel_id);
1626 /*******************************************************************************
1628 ** Function btif_hl_get_app_id
1630 ** Description get the applicaiton id associated with the channel id
1634 *******************************************************************************/
1636 static UINT8 btif_hl_get_app_id(int channel_id){
1637 UINT8 app_id =(UINT8) (channel_id >> 16);
1638 BTIF_TRACE_DEBUG("%s channel_id=0x%08x, app_id=0x%02x ", __FUNCTION__,channel_id, app_id);
1641 /*******************************************************************************
1643 ** Function btif_hl_init_next_app_id
1645 ** Description initialize the application id
1649 *******************************************************************************/
1650 static void btif_hl_init_next_app_id(void){
1651 btif_hl_cb.next_app_id = 1;
1653 /*******************************************************************************
1655 ** Function btif_hl_init_next_channel_id
1657 ** Description initialize the channel id
1661 *******************************************************************************/
1662 static void btif_hl_init_next_channel_id(void){
1663 btif_hl_cb.next_channel_id = 1;
1667 /*******************************************************************************
1669 ** Function btif_hl_find_app_idx_using_handle
1671 ** Description Find the applicaiton index using handle
1675 *******************************************************************************/
1676 BOOLEAN btif_hl_find_app_idx_using_handle(tBTA_HL_APP_HANDLE app_handle,
1678 BOOLEAN found=FALSE;
1681 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1683 if (btif_hl_cb.acb[i].in_use &&
1684 (btif_hl_cb.acb[i].app_handle == app_handle))
1692 BTIF_TRACE_EVENT("%s status=%d handle=%d app_idx=%d ",
1693 __FUNCTION__, found, app_handle , i);
1698 /*******************************************************************************
1700 ** Function btif_hl_find_app_idx_using_app_id
1702 ** Description Find the applicaiton index using app_id
1706 *******************************************************************************/
1707 BOOLEAN btif_hl_find_app_idx_using_app_id(UINT8 app_id,
1709 BOOLEAN found=FALSE;
1713 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1715 if (btif_hl_cb.acb[i].in_use &&
1716 (btif_hl_cb.acb[i].app_id == app_id))
1724 BTIF_TRACE_EVENT("%s found=%d app_id=%d app_idx=%d ",
1725 __FUNCTION__, found, app_id , i);
1730 /*******************************************************************************
1732 ** Function btif_hl_find_mcl_idx_using_handle
1734 ** Description Find the MCL index using handle
1738 *******************************************************************************/
1739 BOOLEAN btif_hl_find_mcl_idx_using_handle( tBTA_HL_MCL_HANDLE mcl_handle,
1740 UINT8 *p_app_idx, UINT8 *p_mcl_idx){
1741 btif_hl_app_cb_t *p_acb;
1742 BOOLEAN found=FALSE;
1745 for (i=0; i<BTA_HL_NUM_APPS; i++)
1747 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
1748 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
1750 if (p_acb->mcb[j].in_use)
1751 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_handle:app_idx=%d,"
1752 "mcl_idx =%d mcl_handle=%d",i,j,p_acb->mcb[j].mcl_handle);
1753 if (p_acb->mcb[j].in_use &&
1754 (p_acb->mcb[j].mcl_handle == mcl_handle))
1763 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d mcl_idx=%d",__FUNCTION__,
1768 /*******************************************************************************
1770 ** Function btif_hl_find_mdl_idx_using_mdl_id
1772 ** Description Find the mdl index using mdl_id
1776 *******************************************************************************/
1777 BOOLEAN btif_hl_find_mcl_idx_using_mdl_id( UINT8 mdl_id,UINT8 mcl_handle,
1778 UINT8 *p_app_idx, UINT8 *p_mcl_idx){
1779 btif_hl_app_cb_t *p_acb;
1780 btif_hl_mcl_cb_t *p_mcb;
1781 BOOLEAN found=FALSE;
1784 for (i=0; i<BTA_HL_NUM_APPS; i++)
1786 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
1787 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
1789 if (p_acb->mcb[j].in_use &&
1790 (p_acb->mcb[j].mcl_handle == mcl_handle))
1792 p_mcb = &p_acb->mcb[j];
1793 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_mdl_id: mcl handle found j =%d",j);
1794 for (x=0; x < BTA_HL_NUM_MDLS_PER_MCL ; x ++)
1796 if (p_mcb->mdl[x].in_use && p_mcb->mdl[x].mdl_id == mdl_id)
1798 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_mdl_id:found x =%d",x);
1808 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d mcl_idx=%d",__FUNCTION__,
1813 /*******************************************************************************
1815 ** Function btif_hl_find_mcl_idx_using_deleted_mdl_id
1817 ** Description Find the app index deleted_mdl_id
1821 *******************************************************************************/
1822 BOOLEAN btif_hl_find_app_idx_using_deleted_mdl_id( UINT8 mdl_id,
1824 btif_hl_app_cb_t *p_acb;
1825 BOOLEAN found=FALSE;
1828 for (i=0; i<BTA_HL_NUM_APPS; i++)
1830 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
1831 if (p_acb->delete_mdl.active) {
1832 BTIF_TRACE_DEBUG("btif_hl_find_app_idx_using_deleted_mdl_id: app_idx=%d,"
1833 "mdl_id=%d mcl_handle=%d",i,mdl_id,p_acb->mcb[i].mcl_handle);
1835 if (p_acb->delete_mdl.active &&
1836 (p_acb->delete_mdl.mdl_id == mdl_id))
1843 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d",__FUNCTION__,
1848 /*******************************************************************************
1850 ** Function btif_hl_stop_timer_using_handle
1852 ** Description clean control channel cb using handle
1856 *******************************************************************************/
1857 static void btif_hl_stop_timer_using_handle( tBTA_HL_MCL_HANDLE mcl_handle){
1858 btif_hl_app_cb_t *p_acb;
1859 BOOLEAN found=FALSE;
1862 for (i=0; i<BTA_HL_NUM_APPS; i++)
1864 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
1865 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
1867 if (p_acb->mcb[j].in_use &&
1868 (p_acb->mcb[j].mcl_handle == mcl_handle))
1870 btif_hl_stop_cch_timer(i, j);
1876 /*******************************************************************************
1878 ** Function btif_hl_find_mcl_idx_using_app_idx
1880 ** Description Find the MCL index using handle
1884 *******************************************************************************/
1885 BOOLEAN btif_hl_find_mcl_idx_using_app_idx( tBTA_HL_MCL_HANDLE mcl_handle,
1886 UINT8 p_app_idx, UINT8 *p_mcl_idx){
1887 btif_hl_app_cb_t *p_acb;
1888 BOOLEAN found=FALSE;
1891 p_acb =BTIF_HL_GET_APP_CB_PTR(p_app_idx);
1892 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
1894 if (p_acb->mcb[j].in_use &&
1895 (p_acb->mcb[j].mcl_handle == mcl_handle))
1902 BTIF_TRACE_DEBUG("%s found=%dmcl_idx=%d",__FUNCTION__,
1907 /*******************************************************************************
1909 ** Function btif_hl_clean_mdls_using_app_idx
1911 ** Description clean dch cpntrol bloack using app_idx
1915 *******************************************************************************/
1916 void btif_hl_clean_mdls_using_app_idx( UINT8 app_idx){
1917 btif_hl_app_cb_t *p_acb;
1918 btif_hl_mcl_cb_t *p_mcb;
1919 btif_hl_mdl_cb_t *p_dcb;
1921 bt_bdaddr_t bd_addr;
1923 p_acb =BTIF_HL_GET_APP_CB_PTR(app_idx);
1924 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
1926 if (p_acb->mcb[j].in_use)
1928 p_mcb = &p_acb->mcb[j];
1929 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_mdl_id: mcl handle found j =%d",j);
1930 for (x=0; x < BTA_HL_NUM_MDLS_PER_MCL ; x ++)
1932 if (p_mcb->mdl[x].in_use)
1934 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, j,x);
1935 btif_hl_release_socket(app_idx,j,x);
1938 bd_addr.address[y] = p_mcb->bd_addr[y];
1940 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, p_acb->app_id,
1941 &bd_addr, p_dcb->local_mdep_cfg_idx,
1942 p_dcb->channel_id, BTHL_CONN_STATE_DISCONNECTED, 0 );
1943 btif_hl_clean_mdl_cb(p_dcb);
1944 if (!btif_hl_num_dchs_in_use(p_mcb->mcl_handle))
1945 BTA_HlCchClose(p_mcb->mcl_handle);
1946 BTIF_TRACE_DEBUG("remote DCH close success mdl_idx=%d", x);
1953 /*******************************************************************************
1955 ** Function btif_hl_find_app_idx
1957 ** Description Find the application index using application ID
1961 *******************************************************************************/
1962 BOOLEAN btif_hl_find_app_idx(UINT8 app_id, UINT8 *p_app_idx){
1963 BOOLEAN found=FALSE;
1966 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1969 if (btif_hl_cb.acb[i].in_use &&
1970 (btif_hl_cb.acb[i].app_id == app_id))
1977 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d", __FUNCTION__, found, i );
1982 /*******************************************************************************
1984 ** Function btif_hl_find_app_idx
1986 ** Description Find the application index using application ID
1990 *******************************************************************************/
1991 BOOLEAN btif_hl_find_app_idx_using_mdepId(UINT8 mdep_id, UINT8 *p_app_idx){
1992 BOOLEAN found=FALSE;
1996 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1998 BTIF_TRACE_DEBUG("btif_hl_find_app_idx_using_mdepId: MDEP-ID = %d",
1999 btif_hl_cb.acb[i].sup_feature.mdep[0].mdep_id);
2000 if (btif_hl_cb.acb[i].in_use &&
2001 (btif_hl_cb.acb[i].sup_feature.mdep[0].mdep_id == mdep_id))
2008 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d", __FUNCTION__, found, i );
2013 /*******************************************************************************
2015 ** Function btif_hl_find_avail_mdl_idx
2017 ** Description Find a not in-use MDL index
2021 *******************************************************************************/
2022 BOOLEAN btif_hl_find_avail_mdl_idx(UINT8 app_idx, UINT8 mcl_idx,
2024 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2025 BOOLEAN found=FALSE;
2028 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
2030 if (!p_mcb->mdl[i].in_use)
2032 btif_hl_clean_mdl_cb(&p_mcb->mdl[i]);
2039 BTIF_TRACE_DEBUG("%s found=%d idx=%d",__FUNCTION__, found, i);
2043 /*******************************************************************************
2045 ** Function btif_hl_find_avail_mcl_idx
2047 ** Description Find a not in-use MDL index
2051 *******************************************************************************/
2052 BOOLEAN btif_hl_find_avail_mcl_idx(UINT8 app_idx, UINT8 *p_mcl_idx){
2053 BOOLEAN found=FALSE;
2056 for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
2058 if (!btif_hl_cb.acb[app_idx].mcb[i].in_use)
2065 BTIF_TRACE_DEBUG("%s found=%d mcl_idx=%d", __FUNCTION__, found, i);
2069 /*******************************************************************************
2071 ** Function btif_hl_find_avail_app_idx
2073 ** Description Find a not in-use APP index
2077 *******************************************************************************/
2078 static BOOLEAN btif_hl_find_avail_app_idx(UINT8 *p_idx){
2079 BOOLEAN found = FALSE;
2082 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
2084 if (!btif_hl_cb.acb[i].in_use)
2092 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d", __FUNCTION__, found, i);
2097 /*******************************************************************************
2099 ** Function btif_hl_proc_dereg_cfm
2101 ** Description Process the de-registration confirmation
2105 *******************************************************************************/
2106 static void btif_hl_proc_dereg_cfm(tBTA_HL *p_data)
2109 btif_hl_app_cb_t *p_acb;
2112 bthl_app_reg_state_t state = BTHL_APP_REG_STATE_DEREG_SUCCESS;
2113 bt_status_t status = BT_STATUS_SUCCESS;
2115 BTIF_TRACE_DEBUG("%s de-reg status=%d app_handle=%d", __FUNCTION__,
2116 p_data->dereg_cfm.status, p_data->dereg_cfm.app_handle);
2118 if (btif_hl_find_app_idx_using_app_id(p_data->dereg_cfm.app_id, &app_idx))
2120 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
2121 app_id = (int) p_acb->app_id;
2122 if (p_data->dereg_cfm.status == BTA_HL_STATUS_OK)
2124 btif_hl_clean_mdls_using_app_idx(app_idx);
2125 memset(p_acb, 0,sizeof(btif_hl_app_cb_t));
2128 state = BTHL_APP_REG_STATE_DEREG_FAILED;
2130 BTIF_TRACE_DEBUG("call reg state callback app_id=%d state=%d", app_id, state);
2131 BTIF_HL_CALL_CBACK(bt_hl_callbacks, app_reg_state_cb, app_id, state );
2133 if (btif_hl_is_no_active_app())
2140 /*******************************************************************************
2142 ** Function btif_hl_proc_reg_cfm
2144 ** Description Process the registration confirmation
2148 *******************************************************************************/
2149 static void btif_hl_proc_reg_cfm(tBTA_HL *p_data){
2150 btif_hl_app_cb_t *p_acb;
2152 bthl_app_reg_state_t state = BTHL_APP_REG_STATE_REG_SUCCESS;
2153 bt_status_t bt_status;
2155 BTIF_TRACE_DEBUG("%s reg status=%d app_handle=%d", __FUNCTION__, p_data->reg_cfm.status, p_data->reg_cfm.app_handle);
2157 if (btif_hl_find_app_idx(p_data->reg_cfm.app_id, &app_idx))
2159 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
2160 if (p_data->reg_cfm.status == BTA_HL_STATUS_OK)
2162 p_acb->app_handle = p_data->reg_cfm.app_handle;
2166 btif_hl_free_app_idx(app_idx);
2168 state = BTHL_APP_REG_STATE_REG_FAILED;
2171 BTIF_TRACE_DEBUG("%s call reg state callback app_id=%d reg state=%d", __FUNCTION__, p_data->reg_cfm.app_id, state);
2172 BTIF_HL_CALL_CBACK(bt_hl_callbacks, app_reg_state_cb, ((int) p_data->reg_cfm.app_id), state );
2176 /*******************************************************************************
2178 ** Function btif_hl_set_chan_cb_state
2180 ** Description set the channel callback state
2184 *******************************************************************************/
2185 void btif_hl_set_chan_cb_state(UINT8 app_idx, UINT8 mcl_idx, btif_hl_chan_cb_state_t state){
2186 btif_hl_pending_chan_cb_t *p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
2187 btif_hl_chan_cb_state_t cur_state = p_pcb->cb_state;
2189 if (cur_state != state)
2191 p_pcb->cb_state = state;
2192 BTIF_TRACE_DEBUG("%s state %d--->%d",__FUNCTION__, cur_state, state);
2197 /*******************************************************************************
2199 ** Function btif_hl_send_destroyed_cb
2201 ** Description send the channel destroyed callback
2205 *******************************************************************************/
2206 void btif_hl_send_destroyed_cb(btif_hl_app_cb_t *p_acb ){
2207 bt_bdaddr_t bd_addr;
2208 int app_id = (int) btif_hl_get_app_id(p_acb->delete_mdl.channel_id);
2210 btif_hl_copy_bda(&bd_addr, p_acb->delete_mdl.bd_addr);
2211 BTIF_TRACE_DEBUG("%s",__FUNCTION__);
2212 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d, state=%d fd=%d",p_acb->delete_mdl.channel_id,
2213 p_acb->delete_mdl.mdep_cfg_idx, BTHL_CONN_STATE_DESTROYED, 0);
2214 btif_hl_display_bt_bda(&bd_addr);
2216 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id,
2217 &bd_addr, p_acb->delete_mdl.mdep_cfg_idx,
2218 p_acb->delete_mdl.channel_id, BTHL_CONN_STATE_DESTROYED, 0 );
2220 /*******************************************************************************
2222 ** Function btif_hl_send_disconnecting_cb
2224 ** Description send a channel disconnecting callback
2228 *******************************************************************************/
2229 void btif_hl_send_disconnecting_cb(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx){
2230 btif_hl_mdl_cb_t *p_dcb = BTIF_HL_GET_MDL_CB_PTR( app_idx, mcl_idx, mdl_idx);
2231 btif_hl_soc_cb_t *p_scb = p_dcb->p_scb;
2232 bt_bdaddr_t bd_addr;
2233 int app_id = (int) btif_hl_get_app_id(p_scb->channel_id);
2235 btif_hl_copy_bda(&bd_addr, p_scb->bd_addr);
2237 BTIF_TRACE_DEBUG("%s",__FUNCTION__);
2238 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d, state=%d fd=%d",p_scb->channel_id,
2239 p_scb->mdep_cfg_idx, BTHL_CONN_STATE_DISCONNECTING, p_scb->socket_id[0]);
2240 btif_hl_display_bt_bda(&bd_addr);
2241 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id,
2242 &bd_addr, p_scb->mdep_cfg_idx,
2243 p_scb->channel_id, BTHL_CONN_STATE_DISCONNECTING, p_scb->socket_id[0] );
2245 /*******************************************************************************
2247 ** Function btif_hl_send_setup_connecting_cb
2249 ** Description send a channel connecting callback
2253 *******************************************************************************/
2254 void btif_hl_send_setup_connecting_cb(UINT8 app_idx, UINT8 mcl_idx){
2255 btif_hl_pending_chan_cb_t *p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
2256 bt_bdaddr_t bd_addr;
2257 int app_id = (int) btif_hl_get_app_id(p_pcb->channel_id);
2259 btif_hl_copy_bda(&bd_addr, p_pcb->bd_addr);
2261 if (p_pcb->in_use && p_pcb->cb_state == BTIF_HL_CHAN_CB_STATE_CONNECTING_PENDING)
2263 BTIF_TRACE_DEBUG("%s",__FUNCTION__);
2264 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d state=%d fd=%d",p_pcb->channel_id,
2265 p_pcb->mdep_cfg_idx, BTHL_CONN_STATE_CONNECTING, 0);
2266 btif_hl_display_bt_bda(&bd_addr);
2268 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id,
2269 &bd_addr, p_pcb->mdep_cfg_idx,
2270 p_pcb->channel_id, BTHL_CONN_STATE_CONNECTING, 0 );
2271 btif_hl_set_chan_cb_state(app_idx, mcl_idx, BTIF_HL_CHAN_CB_STATE_CONNECTED_PENDING);
2274 /*******************************************************************************
2276 ** Function btif_hl_send_setup_disconnected_cb
2278 ** Description send a channel disconnected callback
2282 *******************************************************************************/
2283 void btif_hl_send_setup_disconnected_cb(UINT8 app_idx, UINT8 mcl_idx){
2284 btif_hl_pending_chan_cb_t *p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
2285 bt_bdaddr_t bd_addr;
2286 int app_id = (int) btif_hl_get_app_id(p_pcb->channel_id);
2288 btif_hl_copy_bda(&bd_addr, p_pcb->bd_addr);
2290 BTIF_TRACE_DEBUG("%s p_pcb->in_use=%d",__FUNCTION__, p_pcb->in_use);
2293 BTIF_TRACE_DEBUG("%p_pcb->cb_state=%d",p_pcb->cb_state);
2294 if (p_pcb->cb_state == BTIF_HL_CHAN_CB_STATE_CONNECTING_PENDING)
2296 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d state=%d fd=%d",p_pcb->channel_id,
2297 p_pcb->mdep_cfg_idx, BTHL_CONN_STATE_CONNECTING, 0);
2298 btif_hl_display_bt_bda(&bd_addr);
2299 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id,
2300 &bd_addr, p_pcb->mdep_cfg_idx,
2301 p_pcb->channel_id, BTHL_CONN_STATE_CONNECTING, 0 );
2303 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d state=%d fd=%d",p_pcb->channel_id,
2304 p_pcb->mdep_cfg_idx, BTHL_CONN_STATE_DISCONNECTED, 0);
2305 btif_hl_display_bt_bda(&bd_addr);
2306 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id,
2307 &bd_addr, p_pcb->mdep_cfg_idx,
2308 p_pcb->channel_id, BTHL_CONN_STATE_DISCONNECTED, 0 );
2310 else if (p_pcb->cb_state == BTIF_HL_CHAN_CB_STATE_CONNECTED_PENDING)
2312 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d state=%d fd=%d",p_pcb->channel_id,
2313 p_pcb->mdep_cfg_idx, BTHL_CONN_STATE_DISCONNECTED, 0);
2314 btif_hl_display_bt_bda(&bd_addr);
2315 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id,
2316 &bd_addr, p_pcb->mdep_cfg_idx,
2317 p_pcb->channel_id, BTHL_CONN_STATE_DISCONNECTED, 0 );
2319 btif_hl_clean_pcb(p_pcb);
2322 /*******************************************************************************
2324 ** Function btif_hl_proc_sdp_query_cfm
2326 ** Description Process the SDP query confirmation
2330 *******************************************************************************/
2331 static BOOLEAN btif_hl_proc_sdp_query_cfm(tBTA_HL *p_data){
2332 btif_hl_app_cb_t *p_acb;
2333 btif_hl_mcl_cb_t *p_mcb;
2335 tBTA_HL_CCH_OPEN_PARAM open_param;
2336 UINT8 app_idx, mcl_idx, sdp_idx = 0;
2337 UINT8 num_recs, i, num_mdeps, j;
2338 btif_hl_cch_op_t old_cch_oper;
2339 BOOLEAN status =FALSE;
2340 btif_hl_pending_chan_cb_t *p_pcb;
2342 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2344 p_sdp = p_data->sdp_query_cfm.p_sdp;
2345 num_recs = p_sdp->num_recs;
2347 BTIF_TRACE_DEBUG("num of SDP records=%d",num_recs);
2348 for (i=0; i<num_recs; i++)
2350 BTIF_TRACE_DEBUG("rec_idx=%d ctrl_psm=0x%x data_psm=0x%x",
2351 (i+1),p_sdp->sdp_rec[i].ctrl_psm, p_sdp->sdp_rec[i].data_psm);
2352 BTIF_TRACE_DEBUG("MCAP supported procedures=0x%x",p_sdp->sdp_rec[i].mcap_sup_proc);
2353 num_mdeps = p_sdp->sdp_rec[i].num_mdeps;
2354 BTIF_TRACE_DEBUG("num of mdeps =%d",num_mdeps);
2355 for (j=0; j< num_mdeps; j++)
2357 BTIF_TRACE_DEBUG("mdep_idx=%d mdep_id=0x%x data_type=0x%x mdep_role=0x%x",
2359 p_sdp->sdp_rec[i].mdep_cfg[j].mdep_id,
2360 p_sdp->sdp_rec[i].mdep_cfg[j].data_type,
2361 p_sdp->sdp_rec[i].mdep_cfg[j].mdep_role );
2365 if (btif_hl_find_app_idx_using_app_id(p_data->sdp_query_cfm.app_id, &app_idx))
2367 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
2369 if (btif_hl_find_mcl_idx(app_idx, p_data->sdp_query_cfm.bd_addr, &mcl_idx))
2371 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2372 if (p_mcb->cch_oper != BTIF_HL_CCH_OP_NONE)
2374 memcpy(&p_mcb->sdp, p_sdp, sizeof(tBTA_HL_SDP));
2375 old_cch_oper = p_mcb->cch_oper;
2376 p_mcb->cch_oper = BTIF_HL_CCH_OP_NONE;
2378 switch (old_cch_oper)
2380 case BTIF_HL_CCH_OP_MDEP_FILTERING:
2381 status = btif_hl_find_sdp_idx_using_mdep_filter(app_idx,
2390 p_mcb->sdp_idx = sdp_idx;
2391 p_mcb->valid_sdp_idx = TRUE;
2392 p_mcb->ctrl_psm = p_mcb->sdp.sdp_rec[sdp_idx].ctrl_psm;
2394 switch (old_cch_oper)
2396 case BTIF_HL_CCH_OP_MDEP_FILTERING:
2397 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
2400 if (!p_pcb->abort_pending)
2404 case BTIF_HL_PEND_DCH_OP_OPEN:
2405 btif_hl_send_setup_connecting_cb(app_idx, mcl_idx);
2407 case BTIF_HL_PEND_DCH_OP_DELETE_MDL:
2411 open_param.ctrl_psm = p_mcb->ctrl_psm;
2412 bdcpy(open_param.bd_addr, p_mcb->bd_addr);
2413 open_param.sec_mask =
2414 (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT);
2415 BTA_HlCchOpen(p_acb->app_id,p_acb->app_handle, &open_param);
2419 BTIF_TRACE_DEBUG("channel abort pending");
2424 case BTIF_HL_CCH_OP_DCH_OPEN:
2425 status = btif_hl_proc_pending_op(app_idx,mcl_idx);
2429 BTIF_TRACE_ERROR("Invalid CCH oper %d", old_cch_oper);
2435 BTIF_TRACE_ERROR("Can not find SDP idx discard CCH Open request");
2444 /*******************************************************************************
2446 ** Function btif_hl_proc_cch_open_ind
2448 ** Description Process the CCH open indication
2452 *******************************************************************************/
2453 static void btif_hl_proc_cch_open_ind(tBTA_HL *p_data)
2456 btif_hl_mcl_cb_t *p_mcb;
2457 UINT8 app_idx, mcl_idx;
2460 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2461 for(i=0; i<BTA_HL_NUM_APPS; i++)
2463 if (btif_hl_cb.acb[i].in_use)
2465 if (!btif_hl_find_mcl_idx(i, p_data->cch_open_ind.bd_addr, &mcl_idx))
2467 if (btif_hl_find_avail_mcl_idx(i, &mcl_idx))
2469 p_mcb = BTIF_HL_GET_MCL_CB_PTR(i, mcl_idx);
2470 memset(p_mcb, 0, sizeof(btif_hl_mcl_cb_t));
2471 p_mcb->in_use = TRUE;
2472 p_mcb->is_connected = TRUE;
2473 p_mcb->mcl_handle = p_data->cch_open_ind.mcl_handle;
2474 bdcpy(p_mcb->bd_addr, p_data->cch_open_ind.bd_addr);
2475 btif_hl_start_cch_timer(i, mcl_idx);
2480 BTIF_TRACE_ERROR("The MCL already exist for cch_open_ind");
2486 /*******************************************************************************
2488 ** Function btif_hl_proc_pending_op
2490 ** Description Process the pending dch operation.
2494 *******************************************************************************/
2495 BOOLEAN btif_hl_proc_pending_op(UINT8 app_idx, UINT8 mcl_idx)
2499 btif_hl_app_cb_t *p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
2500 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2501 btif_hl_pending_chan_cb_t *p_pcb;
2502 BOOLEAN status = FALSE;
2503 tBTA_HL_DCH_OPEN_PARAM dch_open;
2504 tBTA_HL_MDL_ID mdl_id;
2505 tBTA_HL_DCH_RECONNECT_PARAM reconnect_param;
2507 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
2512 case BTIF_HL_PEND_DCH_OP_OPEN:
2513 if (!p_pcb->abort_pending)
2515 BTIF_TRACE_DEBUG("op BTIF_HL_PEND_DCH_OP_OPEN");
2516 dch_open.ctrl_psm = p_mcb->ctrl_psm;
2517 dch_open.local_mdep_id = p_acb->sup_feature.mdep[p_pcb->mdep_cfg_idx].mdep_id;
2518 if (btif_hl_find_peer_mdep_id(p_acb->app_id, p_mcb->bd_addr,
2519 p_acb->sup_feature.mdep[p_pcb->mdep_cfg_idx].mdep_cfg.mdep_role,
2520 p_acb->sup_feature.mdep[p_pcb->mdep_cfg_idx].mdep_cfg.data_cfg[0].data_type, &dch_open.peer_mdep_id ))
2522 dch_open.local_cfg = p_acb->channel_type[p_pcb->mdep_cfg_idx];
2523 if ((p_acb->sup_feature.mdep[p_pcb->mdep_cfg_idx].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
2524 && !btif_hl_is_the_first_reliable_existed(app_idx, mcl_idx))
2526 dch_open.local_cfg = BTA_HL_DCH_CFG_RELIABLE;
2528 dch_open.sec_mask = (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT);
2529 BTIF_TRACE_DEBUG("dch_open.local_cfg=%d ", dch_open.local_cfg);
2530 btif_hl_send_setup_connecting_cb(app_idx,mcl_idx);
2532 if (!btif_hl_is_reconnect_possible(app_idx, mcl_idx, p_pcb->mdep_cfg_idx, &dch_open, &mdl_id ))
2534 BTIF_TRACE_DEBUG("Issue DCH open, mcl_handle=%d",p_mcb->mcl_handle);
2535 BTA_HlDchOpen(p_mcb->mcl_handle, &dch_open);
2539 reconnect_param.ctrl_psm = p_mcb->ctrl_psm;
2540 reconnect_param.mdl_id = mdl_id;;
2541 BTIF_TRACE_DEBUG("Issue Reconnect ctrl_psm=0x%x mdl_id=0x%x",reconnect_param.ctrl_psm, reconnect_param.mdl_id);
2542 BTA_HlDchReconnect(p_mcb->mcl_handle, &reconnect_param);
2549 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx);
2553 case BTIF_HL_PEND_DCH_OP_DELETE_MDL:
2554 BTA_HlDeleteMdl(p_mcb->mcl_handle, p_acb->delete_mdl.mdl_id);
2565 /*******************************************************************************
2567 ** Function btif_hl_proc_cch_open_cfm
2569 ** Description Process the CCH open confirmation
2573 *******************************************************************************/
2574 static BOOLEAN btif_hl_proc_cch_open_cfm(tBTA_HL *p_data)
2577 btif_hl_app_cb_t *p_acb;
2578 btif_hl_mcl_cb_t *p_mcb;
2579 UINT8 app_idx, mcl_idx;
2580 BOOLEAN status = FALSE;
2581 tBTA_HL_DCH_OPEN_PARAM dch_open;
2583 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2585 if (btif_hl_find_app_idx_using_app_id(p_data->cch_open_cfm.app_id, &app_idx))
2587 BTIF_TRACE_DEBUG("app_idx=%d", app_idx);
2588 if (btif_hl_find_mcl_idx(app_idx, p_data->cch_open_cfm.bd_addr, &mcl_idx))
2590 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
2592 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2593 BTIF_TRACE_DEBUG("mcl_idx=%d, mcl_handle=%d", mcl_idx,p_data->cch_open_cfm.mcl_handle);
2594 p_mcb->mcl_handle = p_data->cch_open_cfm.mcl_handle;
2595 p_mcb->is_connected = TRUE;
2596 status = btif_hl_proc_pending_op(app_idx, mcl_idx);
2598 btif_hl_start_cch_timer(app_idx, mcl_idx);
2605 /*******************************************************************************
2607 ** Function btif_hl_clean_mcb_using_handle
2609 ** Description clean control channel cb using handle
2613 *******************************************************************************/
2614 static void btif_hl_clean_mcb_using_handle( tBTA_HL_MCL_HANDLE mcl_handle){
2615 btif_hl_app_cb_t *p_acb;
2618 for (i=0; i<BTA_HL_NUM_APPS; i++)
2620 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
2621 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
2623 if (p_acb->mcb[j].in_use)
2624 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_handle: app_idx=%d,"
2625 "mcl_idx =%d mcl_handle=%d",i,j,p_acb->mcb[j].mcl_handle);
2626 if (p_acb->mcb[j].in_use &&
2627 (p_acb->mcb[j].mcl_handle == mcl_handle))
2629 btif_hl_stop_cch_timer(i, j);
2630 btif_hl_release_mcl_sockets(i, j);
2631 btif_hl_send_setup_disconnected_cb(i, j);
2632 btif_hl_clean_mcl_cb(i, j);
2638 /*******************************************************************************
2640 ** Function btif_hl_proc_cch_close_ind
2642 ** Description Process the CCH close indication
2646 *******************************************************************************/
2647 static void btif_hl_proc_cch_close_ind(tBTA_HL *p_data)
2650 UINT8 app_idx, mcl_idx;
2651 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2653 btif_hl_clean_mcb_using_handle(p_data->cch_close_ind.mcl_handle);
2657 /*******************************************************************************
2659 ** Function btif_hl_proc_cch_close_cfm
2661 ** Description Process the CCH close confirmation
2665 *******************************************************************************/
2666 static void btif_hl_proc_cch_close_cfm(tBTA_HL *p_data)
2668 UINT8 app_idx, mcl_idx;
2669 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2671 btif_hl_clean_mcb_using_handle(p_data->cch_close_ind.mcl_handle);
2674 /*******************************************************************************
2676 ** Function btif_hl_proc_create_ind
2678 ** Description Process the MDL create indication
2682 *******************************************************************************/
2683 static void btif_hl_proc_create_ind(tBTA_HL *p_data){
2684 btif_hl_app_cb_t *p_acb;
2685 btif_hl_mcl_cb_t *p_mcb;
2686 tBTA_HL_MDEP *p_mdep;
2687 UINT8 app_idx, orig_app_idx, mcl_idx, mdep_cfg_idx;
2688 BOOLEAN first_reliable_exist;
2689 BOOLEAN success = TRUE;
2690 tBTA_HL_DCH_CFG rsp_cfg = BTA_HL_DCH_CFG_UNKNOWN;
2691 tBTA_HL_DCH_CREATE_RSP rsp_code = BTA_HL_DCH_CREATE_RSP_CFG_REJ;
2692 tBTA_HL_DCH_CREATE_RSP_PARAM create_rsp_param;
2694 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2696 // Find the correct app_idx based on the mdep_id;
2697 btif_hl_find_app_idx_using_mdepId(p_data->dch_create_ind.local_mdep_id,&orig_app_idx);
2698 if (btif_hl_find_mcl_idx(orig_app_idx, p_data->dch_create_ind.bd_addr, &mcl_idx))
2700 p_acb =BTIF_HL_GET_APP_CB_PTR(orig_app_idx);
2701 p_mcb =BTIF_HL_GET_MCL_CB_PTR(orig_app_idx, mcl_idx);
2703 if (btif_hl_find_mdep_cfg_idx(orig_app_idx, p_data->dch_create_ind.local_mdep_id, &mdep_cfg_idx))
2705 p_mdep = &(p_acb->sup_feature.mdep[mdep_cfg_idx]);
2706 first_reliable_exist = btif_hl_is_the_first_reliable_existed(orig_app_idx, mcl_idx);
2707 switch (p_mdep->mdep_cfg.mdep_role)
2709 case BTA_HL_MDEP_ROLE_SOURCE:
2710 if (p_data->dch_create_ind.cfg == BTA_HL_DCH_CFG_NO_PREF)
2712 if (first_reliable_exist)
2714 rsp_cfg = p_acb->channel_type[mdep_cfg_idx];
2718 rsp_cfg = BTA_HL_DCH_CFG_RELIABLE;
2720 rsp_code = BTA_HL_DCH_CREATE_RSP_SUCCESS;
2724 case BTA_HL_MDEP_ROLE_SINK:
2726 BTIF_TRACE_DEBUG("btif_hl_proc_create_ind:BTA_HL_MDEP_ROLE_SINK");
2727 if ((p_data->dch_create_ind.cfg == BTA_HL_DCH_CFG_RELIABLE) ||
2728 (first_reliable_exist && (p_data->dch_create_ind.cfg == BTA_HL_DCH_CFG_STREAMING)))
2730 rsp_code = BTA_HL_DCH_CREATE_RSP_SUCCESS;
2731 rsp_cfg = p_data->dch_create_ind.cfg;
2732 BTIF_TRACE_DEBUG("btif_hl_proc_create_ind:BTA_HL_MDEP_ROLE_SINK cfg = %d",rsp_cfg);
2747 BTIF_TRACE_DEBUG("create response rsp_code=%d rsp_cfg=%d", rsp_code, rsp_cfg );
2748 create_rsp_param.local_mdep_id = p_data->dch_create_ind.local_mdep_id;
2749 create_rsp_param.mdl_id = p_data->dch_create_ind.mdl_id;
2750 create_rsp_param.rsp_code = rsp_code;
2751 create_rsp_param.cfg_rsp = rsp_cfg;
2752 BTA_HlDchCreateRsp(p_mcb->mcl_handle, &create_rsp_param);
2756 /*******************************************************************************
2758 ** Function btif_hl_proc_dch_open_ind
2760 ** Description Process the DCH open indication
2764 *******************************************************************************/
2765 static void btif_hl_proc_dch_open_ind(tBTA_HL *p_data)
2768 btif_hl_app_cb_t *p_acb;
2769 btif_hl_mcl_cb_t *p_mcb;
2770 btif_hl_mdl_cb_t *p_dcb;
2771 UINT8 orig_app_idx, mcl_idx, mdl_idx, mdep_cfg_idx;
2773 BOOLEAN close_dch = FALSE;
2775 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2777 // Find the correct app_idx based on the mdep_id;
2778 btif_hl_find_app_idx_using_mdepId(p_data->dch_open_ind.local_mdep_id,&orig_app_idx);
2780 if (btif_hl_find_mcl_idx_using_app_idx(p_data->dch_open_ind.mcl_handle, orig_app_idx, &mcl_idx ))
2782 p_acb =BTIF_HL_GET_APP_CB_PTR(orig_app_idx);
2783 p_mcb =BTIF_HL_GET_MCL_CB_PTR(orig_app_idx, mcl_idx);
2785 if (btif_hl_find_avail_mdl_idx(orig_app_idx, mcl_idx, &mdl_idx))
2787 p_dcb = BTIF_HL_GET_MDL_CB_PTR(orig_app_idx, mcl_idx, mdl_idx);
2789 if (btif_hl_find_mdep_cfg_idx(orig_app_idx, p_data->dch_open_ind.local_mdep_id, &mdep_cfg_idx))
2791 p_dcb->in_use = TRUE;
2792 p_dcb->mdl_handle = p_data->dch_open_ind.mdl_handle;
2793 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx;
2794 p_dcb->local_mdep_id = p_data->dch_open_ind.local_mdep_id;
2795 p_dcb->mdl_id = p_data->dch_open_ind.mdl_id;
2796 p_dcb->dch_mode = p_data->dch_open_ind.dch_mode;
2797 p_dcb->dch_mode = p_data->dch_open_ind.dch_mode;
2798 p_dcb->is_the_first_reliable = p_data->dch_open_ind.first_reliable;
2799 p_dcb->mtu = p_data->dch_open_ind.mtu;
2801 if(btif_hl_find_channel_id_using_mdl_id(orig_app_idx,p_dcb->mdl_id , &p_dcb->channel_id))
2803 BTIF_TRACE_DEBUG(" app_idx=%d mcl_idx=%d mdl_idx=%d channel_id=%d",
2804 orig_app_idx, mcl_idx, mdl_idx, p_dcb->channel_id );
2805 if (!btif_hl_create_socket(orig_app_idx, mcl_idx, mdl_idx))
2807 BTIF_TRACE_ERROR("Unable to create socket");
2813 BTIF_TRACE_ERROR("Unable find channel id for mdl_id=0x%x", p_dcb->mdl_id );
2819 BTIF_TRACE_ERROR("INVALID_LOCAL_MDEP_ID mdep_id=%d",p_data->dch_open_cfm.local_mdep_id);
2824 btif_hl_clean_mdl_cb(p_dcb);
2833 BTA_HlDchClose(p_data->dch_open_cfm.mdl_handle);
2836 /*******************************************************************************
2838 ** Function btif_hl_proc_dch_open_cfm
2840 ** Description Process the DCH close confirmation
2844 *******************************************************************************/
2845 static BOOLEAN btif_hl_proc_dch_open_cfm(tBTA_HL *p_data)
2848 btif_hl_app_cb_t *p_acb;
2849 btif_hl_mcl_cb_t *p_mcb;
2850 btif_hl_mdl_cb_t *p_dcb;
2851 btif_hl_pending_chan_cb_t *p_pcb;
2852 UINT8 app_idx, mcl_idx, mdl_idx, mdep_cfg_idx;
2853 BOOLEAN status = FALSE;
2854 BOOLEAN close_dch = FALSE;
2856 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2858 // Find the correct app_idx based on the mdep_id;
2859 btif_hl_find_app_idx_using_mdepId(p_data->dch_open_cfm.local_mdep_id,&app_idx);
2861 if (btif_hl_find_mcl_idx_using_app_idx(p_data->dch_open_cfm.mcl_handle, app_idx, &mcl_idx ))
2863 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
2864 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2865 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
2867 if (btif_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx))
2869 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2871 if (btif_hl_find_mdep_cfg_idx(app_idx, p_data->dch_open_cfm.local_mdep_id, &mdep_cfg_idx))
2873 p_dcb->in_use = TRUE;
2874 p_dcb->mdl_handle = p_data->dch_open_cfm.mdl_handle;
2875 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx;
2876 p_dcb->local_mdep_id = p_data->dch_open_cfm.local_mdep_id;
2877 p_dcb->mdl_id = p_data->dch_open_cfm.mdl_id;
2878 p_dcb->dch_mode = p_data->dch_open_cfm.dch_mode;
2879 p_dcb->is_the_first_reliable= p_data->dch_open_cfm.first_reliable;
2880 p_dcb->mtu = p_data->dch_open_cfm.mtu;
2881 p_dcb->channel_id = p_pcb->channel_id;
2883 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d mdl_idx=%d", app_idx, mcl_idx, mdl_idx );
2884 btif_hl_send_setup_connecting_cb(app_idx, mcl_idx);
2885 if (btif_hl_create_socket(app_idx, mcl_idx, mdl_idx))
2888 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d mdl_idx=%d p_dcb->channel_id=0x%08x",
2889 app_idx, mcl_idx, mdl_idx, p_dcb->channel_id);
2890 btif_hl_clean_pcb(p_pcb);
2894 BTIF_TRACE_ERROR("Unable to create socket");
2900 BTIF_TRACE_ERROR("INVALID_LOCAL_MDEP_ID mdep_id=%d",p_data->dch_open_cfm.local_mdep_id);
2906 btif_hl_clean_mdl_cb(p_dcb);
2907 BTA_HlDchClose(p_data->dch_open_cfm.mdl_handle);
2914 /*******************************************************************************
2916 ** Function btif_hl_proc_dch_reconnect_cfm
2918 ** Description Process the DCH reconnect indication
2922 *******************************************************************************/
2923 static BOOLEAN btif_hl_proc_dch_reconnect_cfm(tBTA_HL *p_data)
2925 btif_hl_app_cb_t *p_acb;
2926 btif_hl_mcl_cb_t *p_mcb;
2927 btif_hl_mdl_cb_t *p_dcb;
2928 btif_hl_pending_chan_cb_t *p_pcb;
2929 UINT8 app_idx, mcl_idx, mdl_idx, mdep_cfg_idx;
2930 BOOLEAN status = FALSE;
2931 BOOLEAN close_dch = FALSE;
2933 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2935 btif_hl_find_app_idx_using_mdepId(p_data->dch_reconnect_cfm.local_mdep_id,&app_idx);
2937 if (btif_hl_find_mcl_idx_using_app_idx(p_data->dch_reconnect_cfm.mcl_handle, app_idx, &mcl_idx ))
2939 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
2940 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2941 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
2943 if (btif_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx))
2945 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2947 if (btif_hl_find_mdep_cfg_idx(app_idx, p_data->dch_reconnect_cfm.local_mdep_id, &mdep_cfg_idx))
2949 p_dcb->in_use = TRUE;
2950 p_dcb->mdl_handle = p_data->dch_reconnect_cfm.mdl_handle;
2951 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx;
2952 p_dcb->local_mdep_id = p_data->dch_reconnect_cfm.local_mdep_id;
2953 p_dcb->mdl_id = p_data->dch_reconnect_cfm.mdl_id;
2954 p_dcb->dch_mode = p_data->dch_reconnect_cfm.dch_mode;
2955 p_dcb->is_the_first_reliable= p_data->dch_reconnect_cfm.first_reliable;
2956 p_dcb->mtu = p_data->dch_reconnect_cfm.mtu;
2957 p_dcb->channel_id = p_pcb->channel_id;
2959 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d mdl_idx=%d", app_idx, mcl_idx, mdl_idx );
2960 btif_hl_send_setup_connecting_cb(app_idx, mcl_idx);
2961 if (btif_hl_create_socket(app_idx, mcl_idx, mdl_idx))
2964 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d mdl_idx=%d p_dcb->channel_id=0x%08x",
2965 app_idx, mcl_idx, mdl_idx, p_dcb->channel_id);
2966 btif_hl_clean_pcb(p_pcb);
2970 BTIF_TRACE_ERROR("Unable to create socket");
2976 BTIF_TRACE_ERROR("INVALID_LOCAL_MDEP_ID mdep_id=%d",p_data->dch_open_cfm.local_mdep_id);
2982 btif_hl_clean_mdl_cb(p_dcb);
2983 BTA_HlDchClose(p_data->dch_reconnect_cfm.mdl_handle);
2991 /*******************************************************************************
2993 ** Function btif_hl_proc_dch_reconnect_ind
2995 ** Description Process the DCH reconnect indication
2999 *******************************************************************************/
3000 static void btif_hl_proc_dch_reconnect_ind(tBTA_HL *p_data)
3003 btif_hl_app_cb_t *p_acb;
3004 btif_hl_mcl_cb_t *p_mcb;
3005 btif_hl_mdl_cb_t *p_dcb;
3006 UINT8 app_idx, mcl_idx, mdl_idx, mdep_cfg_idx, dc_cfg;
3007 BOOLEAN close_dch = FALSE;
3009 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
3011 // Find the correct app_idx based on the mdep_id;
3012 btif_hl_find_app_idx_using_mdepId(p_data->dch_reconnect_ind.local_mdep_id,&app_idx);
3014 if (btif_hl_find_mcl_idx_using_app_idx(p_data->dch_reconnect_ind.mcl_handle, app_idx, &mcl_idx ))
3016 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
3017 BTIF_TRACE_DEBUG("btif_hl_proc_dch_reconnect_ind: app_idx = %d, mcl_idx = %d",
3019 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
3021 if (btif_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx))
3023 p_dcb =BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
3025 if (btif_hl_find_mdep_cfg_idx(app_idx, p_data->dch_reconnect_ind.local_mdep_id, &mdep_cfg_idx))
3027 p_dcb->in_use = TRUE;
3028 p_dcb->mdl_handle = p_data->dch_reconnect_ind.mdl_handle;
3029 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx;
3030 p_dcb->local_mdep_id = p_data->dch_reconnect_ind.local_mdep_id;
3031 p_dcb->mdl_id = p_data->dch_reconnect_ind.mdl_id;
3032 p_dcb->dch_mode = p_data->dch_reconnect_ind.dch_mode;
3033 p_dcb->dch_mode = p_data->dch_reconnect_ind.dch_mode;
3034 p_dcb->is_the_first_reliable= p_data->dch_reconnect_ind.first_reliable;
3035 p_dcb->mtu = p_data->dch_reconnect_ind.mtu;
3036 p_dcb->channel_id = btif_hl_get_next_channel_id(p_acb->app_id);
3038 BTIF_TRACE_DEBUG(" app_idx=%d mcl_idx=%d mdl_idx=%d channel_id=%d",
3039 app_idx, mcl_idx, mdl_idx, p_dcb->channel_id );
3040 if (!btif_hl_create_socket(app_idx, mcl_idx, mdl_idx))
3042 BTIF_TRACE_ERROR("Unable to create socket");
3048 BTIF_TRACE_ERROR("INVALID_LOCAL_MDEP_ID mdep_id=%d",p_data->dch_open_cfm.local_mdep_id);
3053 btif_hl_clean_mdl_cb(p_dcb);
3062 BTA_HlDchClose(p_data->dch_reconnect_ind.mdl_handle);
3066 /*******************************************************************************
3068 ** Function btif_hl_proc_dch_close_ind
3070 ** Description Process the DCH close indication
3074 *******************************************************************************/
3075 static void btif_hl_proc_dch_close_ind(tBTA_HL *p_data)
3078 btif_hl_mdl_cb_t *p_dcb;
3079 btif_hl_mcl_cb_t *p_mcb;
3080 UINT8 app_idx, mcl_idx, mdl_idx;
3082 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
3083 if (btif_hl_find_mdl_idx_using_handle(p_data->dch_close_ind.mdl_handle,
3084 &app_idx, &mcl_idx, &mdl_idx ))
3086 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
3087 btif_hl_release_socket(app_idx,mcl_idx, mdl_idx);
3088 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx);
3089 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx,mcl_idx);
3090 btif_hl_clean_mdl_cb(p_dcb);
3091 if (!btif_hl_num_dchs_in_use(p_mcb->mcl_handle))
3092 btif_hl_start_cch_timer(app_idx, mcl_idx);
3093 BTIF_TRACE_DEBUG("remote DCH close success mdl_idx=%d", mdl_idx);
3097 /*******************************************************************************
3099 ** Function btif_hl_proc_dch_close_cfm
3101 ** Description Process the DCH reconnect confirmation
3105 *******************************************************************************/
3106 static void btif_hl_proc_dch_close_cfm(tBTA_HL *p_data)
3109 btif_hl_mdl_cb_t *p_dcb;
3110 btif_hl_mcl_cb_t *p_mcb;
3111 UINT8 app_idx, mcl_idx, mdl_idx;
3113 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
3114 if (btif_hl_find_mdl_idx_using_handle(p_data->dch_close_cfm.mdl_handle,
3115 &app_idx, &mcl_idx, &mdl_idx ))
3117 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
3118 btif_hl_release_socket(app_idx,mcl_idx,mdl_idx);
3119 btif_hl_clean_mdl_cb(p_dcb);
3120 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx,mcl_idx);
3121 if (!btif_hl_num_dchs_in_use(p_mcb->mcl_handle))
3122 btif_hl_start_cch_timer(app_idx, mcl_idx);
3123 BTIF_TRACE_DEBUG(" local DCH close success mdl_idx=%d", mdl_idx);
3128 /*******************************************************************************
3130 ** Function btif_hl_proc_abort_ind
3132 ** Description Process the abort indicaiton
3136 *******************************************************************************/
3137 static void btif_hl_proc_abort_ind(tBTA_HL_MCL_HANDLE mcl_handle){
3139 UINT8 app_idx,mcl_idx;
3140 BTIF_TRACE_DEBUG("%s", __FUNCTION__ );
3141 btif_hl_app_cb_t *p_acb;
3144 for (i=0; i<BTA_HL_NUM_APPS; i++)
3146 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
3147 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
3149 if (p_acb->mcb[j].in_use)
3150 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_handle: app_idx=%d,mcl_idx =%d mcl_handle=%d",i,j,p_acb->mcb[j].mcl_handle);
3151 if (p_acb->mcb[j].in_use &&
3152 (p_acb->mcb[j].mcl_handle == mcl_handle))
3154 btif_hl_stop_cch_timer(i, j);
3155 btif_hl_send_setup_disconnected_cb(i, j);
3156 btif_hl_clean_mcl_cb(i, j);
3162 /*******************************************************************************
3164 ** Function btif_hl_proc_abort_cfm
3166 ** Description Process the abort confirmation
3170 *******************************************************************************/
3171 static void btif_hl_proc_abort_cfm(tBTA_HL_MCL_HANDLE mcl_handle){
3172 UINT8 app_idx,mcl_idx;
3174 BTIF_TRACE_DEBUG("%s", __FUNCTION__ );
3175 btif_hl_app_cb_t *p_acb;
3178 for (i=0; i<BTA_HL_NUM_APPS; i++)
3180 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
3181 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
3183 if (p_acb->mcb[j].in_use)
3184 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_handle: app_idx=%d,mcl_idx =%d mcl_handle=%d",i,j,p_acb->mcb[j].mcl_handle);
3185 if (p_acb->mcb[j].in_use &&
3186 (p_acb->mcb[j].mcl_handle == mcl_handle))
3188 btif_hl_stop_cch_timer(i, j);
3189 btif_hl_send_setup_disconnected_cb(i, j);
3190 btif_hl_clean_mcl_cb(i, j);
3197 /*******************************************************************************
3199 ** Function btif_hl_proc_send_data_cfm
3201 ** Description Process the send data confirmation
3205 *******************************************************************************/
3206 static void btif_hl_proc_send_data_cfm(tBTA_HL_MDL_HANDLE mdl_handle,
3207 tBTA_HL_STATUS status){
3208 UINT8 app_idx,mcl_idx, mdl_idx;
3209 btif_hl_mdl_cb_t *p_dcb;
3212 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
3213 if (btif_hl_find_mdl_idx_using_handle(mdl_handle,
3214 &app_idx, &mcl_idx, &mdl_idx ))
3216 p_dcb =BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
3217 btif_hl_free_buf((void **) &p_dcb->p_tx_pkt);
3218 BTIF_TRACE_DEBUG("send success free p_tx_pkt tx_size=%d", p_dcb->tx_size);
3223 /*******************************************************************************
3225 ** Function btif_hl_proc_dch_cong_ind
3227 ** Description Process the DCH congestion change indication
3231 *******************************************************************************/
3232 static void btif_hl_proc_dch_cong_ind(tBTA_HL *p_data)
3235 btif_hl_mdl_cb_t *p_dcb;
3236 UINT8 app_idx, mcl_idx, mdl_idx;
3238 BTIF_TRACE_DEBUG("btif_hl_proc_dch_cong_ind");
3241 if (btif_hl_find_mdl_idx_using_handle(p_data->dch_cong_ind.mdl_handle, &app_idx, &mcl_idx, &mdl_idx))
3243 p_dcb =BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
3244 p_dcb->cong = p_data->dch_cong_ind.cong;
3248 /*******************************************************************************
3250 ** Function btif_hl_proc_reg_request
3252 ** Description Process registration request
3256 *******************************************************************************/
3257 static void btif_hl_proc_reg_request(UINT8 app_idx, UINT8 app_id,
3258 tBTA_HL_REG_PARAM *p_reg_param,
3259 tBTA_HL_CBACK *p_cback){
3260 bt_status_t status= BT_STATUS_SUCCESS;
3262 btif_hl_app_data_t *p_data;
3265 BTIF_TRACE_DEBUG("%s app_idx=%d app_id=%d", __FUNCTION__, app_idx, app_id);
3269 BTIF_TRACE_DEBUG("btif_hl_proc_reg_request: calling uPDATE");
3270 BTA_HlUpdate(app_id, p_reg_param,TRUE, btif_hl_cback);
3273 BTA_HlRegister(app_id, p_reg_param, btif_hl_cback);
3277 /*******************************************************************************
3279 ** Function btif_hl_proc_cb_evt
3281 ** Description Process HL callback events
3285 *******************************************************************************/
3286 static void btif_hl_proc_cb_evt(UINT16 event, char* p_param){
3288 btif_hl_evt_cb_t *p_data = (btif_hl_evt_cb_t *)p_param;
3289 bt_bdaddr_t bd_addr;
3290 bthl_channel_state_t state=BTHL_CONN_STATE_DISCONNECTED;
3291 BOOLEAN send_chan_cb=TRUE;
3292 tBTA_HL_REG_PARAM reg_param;
3293 btif_hl_app_cb_t *p_acb;
3294 bthl_app_reg_state_t reg_state = BTHL_APP_REG_STATE_REG_FAILED;
3297 bt_status_t bt_status;
3299 BTIF_TRACE_DEBUG("%s event %d", __FUNCTION__, event);
3300 btif_hl_display_calling_process_name();
3304 case BTIF_HL_SEND_CONNECTED_CB:
3305 case BTIF_HL_SEND_DISCONNECTED_CB:
3306 if (p_data->chan_cb.cb_state == BTIF_HL_CHAN_CB_STATE_CONNECTED_PENDING)
3307 state = BTHL_CONN_STATE_CONNECTED;
3308 else if (p_data->chan_cb.cb_state == BTIF_HL_CHAN_CB_STATE_DISCONNECTED_PENDING)
3309 state = BTHL_CONN_STATE_DISCONNECTED;
3311 send_chan_cb = FALSE;
3315 btif_hl_copy_bda(&bd_addr, p_data->chan_cb.bd_addr);
3316 BTIF_TRACE_DEBUG("state callbk: ch_id=0x%08x cb_state=%d state=%d fd=%d",
3317 p_data->chan_cb.channel_id,
3318 p_data->chan_cb.cb_state,
3319 state, p_data->chan_cb.fd);
3320 btif_hl_display_bt_bda(&bd_addr);
3321 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, p_data->chan_cb.app_id,
3322 &bd_addr, p_data->chan_cb.mdep_cfg_index,
3323 p_data->chan_cb.channel_id, state, p_data->chan_cb.fd );
3327 case BTIF_HL_REG_APP:
3328 p_acb = BTIF_HL_GET_APP_CB_PTR(p_data->reg.app_idx);
3329 app_id = (int) p_acb->app_id;
3330 BTIF_TRACE_DEBUG("Rcv BTIF_HL_REG_APP app_idx=%d reg_pending=%d", p_data->reg.app_idx, p_acb->reg_pending);
3331 if (btif_hl_get_state() == BTIF_HL_STATE_ENABLED && p_acb->reg_pending)
3333 BTIF_TRACE_DEBUG("Rcv BTIF_HL_REG_APP reg_counter=%d",reg_counter);
3334 p_acb->reg_pending = FALSE;
3335 reg_param.dev_type = p_acb->dev_type;
3336 reg_param.sec_mask = BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT;
3337 reg_param.p_srv_name = p_acb->srv_name;
3338 reg_param.p_srv_desp = p_acb->srv_desp;
3339 reg_param.p_provider_name = p_acb->provider_name;
3340 btif_hl_proc_reg_request (p_data->reg.app_idx, p_acb->app_id, ®_param, btif_hl_cback);
3344 BTIF_TRACE_DEBUG("reg request is processed state=%d reg_pending=%d", btif_hl_get_state(), p_acb->reg_pending);
3349 case BTIF_HL_UNREG_APP:
3350 BTIF_TRACE_DEBUG("Rcv BTIF_HL_UNREG_APP app_idx=%d", p_data->unreg.app_idx );
3351 p_acb = BTIF_HL_GET_APP_CB_PTR(p_data->unreg.app_idx);
3352 if (btif_hl_get_state() == BTIF_HL_STATE_ENABLED)
3354 if(reg_counter >= 1)
3355 BTA_HlUpdate(p_acb->app_id,NULL,FALSE,NULL);
3357 BTA_HlDeregister(p_acb->app_id, p_acb->app_handle);
3360 case BTIF_HL_UPDATE_MDL:
3361 BTIF_TRACE_DEBUG("Rcv BTIF_HL_UPDATE_MDL app_idx=%d", p_data->update_mdl.app_idx );
3362 p_acb = BTIF_HL_GET_APP_CB_PTR(p_data->update_mdl.app_idx);
3366 BTIF_TRACE_ERROR("Unknown event %d", event);
3371 /*******************************************************************************
3373 ** Function btif_hl_upstreams_evt
3375 ** Description Process HL events
3379 *******************************************************************************/
3380 static void btif_hl_upstreams_evt(UINT16 event, char* p_param){
3381 tBTA_HL *p_data = (tBTA_HL *)p_param;
3382 UINT8 app_idx, mcl_idx;
3383 btif_hl_app_cb_t *p_acb;
3384 btif_hl_mcl_cb_t *p_mcb = NULL;
3386 btif_hl_pend_dch_op_t pending_op;
3389 BTIF_TRACE_DEBUG("%s event %d", __FUNCTION__, event);
3390 btif_hl_display_calling_process_name();
3393 case BTA_HL_REGISTER_CFM_EVT:
3394 BTIF_TRACE_DEBUG("Rcv BTA_HL_REGISTER_CFM_EVT");
3395 BTIF_TRACE_DEBUG("app_id=%d app_handle=%d status=%d ",
3396 p_data->reg_cfm.app_id,
3397 p_data->reg_cfm.app_handle,
3398 p_data->reg_cfm.status );
3400 btif_hl_proc_reg_cfm(p_data);
3402 case BTA_HL_SDP_INFO_IND_EVT:
3403 BTIF_TRACE_DEBUG("Rcv BTA_HL_SDP_INFO_IND_EVT");
3404 BTIF_TRACE_DEBUG("app_handle=%d ctrl_psm=0x%04x data_psm=0x%04x x_spec=%d mcap_sup_procs=0x%02x",
3405 p_data->sdp_info_ind.app_handle,
3406 p_data->sdp_info_ind.ctrl_psm,
3407 p_data->sdp_info_ind.data_psm,
3408 p_data->sdp_info_ind.data_x_spec,
3409 p_data->sdp_info_ind.mcap_sup_procs);
3410 //btif_hl_proc_sdp_info_ind(p_data);
3413 case BTA_HL_DEREGISTER_CFM_EVT:
3414 BTIF_TRACE_DEBUG("Rcv BTA_HL_DEREGISTER_CFM_EVT");
3415 BTIF_TRACE_DEBUG("app_handle=%d status=%d ",
3416 p_data->dereg_cfm.app_handle,
3417 p_data->dereg_cfm.status );
3418 btif_hl_proc_dereg_cfm(p_data);
3421 case BTA_HL_SDP_QUERY_CFM_EVT:
3422 BTIF_TRACE_DEBUG("Rcv BTA_HL_SDP_QUERY_CFM_EVT");
3423 BTIF_TRACE_DEBUG("app_handle=%d app_id =%d,status =%d",
3424 p_data->sdp_query_cfm.app_handle,p_data->sdp_query_cfm.app_id,
3425 p_data->sdp_query_cfm.status);
3427 BTIF_TRACE_DEBUG("DB [%02x] [%02x] [%02x] [%02x] [%02x] [%02x]",
3428 p_data->sdp_query_cfm.bd_addr[0], p_data->sdp_query_cfm.bd_addr[1],
3429 p_data->sdp_query_cfm.bd_addr[2], p_data->sdp_query_cfm.bd_addr[3],
3430 p_data->sdp_query_cfm.bd_addr[4], p_data->sdp_query_cfm.bd_addr[5]);
3432 if (p_data->sdp_query_cfm.status == BTA_HL_STATUS_OK)
3433 status = btif_hl_proc_sdp_query_cfm(p_data);
3439 BTIF_TRACE_DEBUG("BTA_HL_SDP_QUERY_CFM_EVT Status = %d",
3440 p_data->sdp_query_cfm.status);
3441 if (btif_hl_find_app_idx_using_app_id(p_data->sdp_query_cfm.app_id, &app_idx))
3443 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
3444 if (btif_hl_find_mcl_idx(app_idx, p_data->sdp_query_cfm.bd_addr, &mcl_idx))
3446 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
3447 if ( (p_mcb->cch_oper == BTIF_HL_CCH_OP_MDEP_FILTERING) ||
3448 (p_mcb->cch_oper == BTIF_HL_CCH_OP_DCH_OPEN) )
3450 pending_op = p_mcb->pcb.op;
3453 case BTIF_HL_PEND_DCH_OP_OPEN:
3454 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx);
3456 case BTIF_HL_PEND_DCH_OP_RECONNECT:
3457 case BTIF_HL_PEND_DCH_OP_DELETE_MDL:
3461 if (!p_mcb->is_connected)
3462 btif_hl_clean_mcl_cb(app_idx, mcl_idx);
3471 case BTA_HL_CCH_OPEN_CFM_EVT:
3472 BTIF_TRACE_DEBUG("Rcv BTA_HL_CCH_OPEN_CFM_EVT");
3473 BTIF_TRACE_DEBUG("app_id=%d,app_handle=%d mcl_handle=%d status =%d",
3474 p_data->cch_open_cfm.app_id,
3475 p_data->cch_open_cfm.app_handle,
3476 p_data->cch_open_cfm.mcl_handle,
3477 p_data->cch_open_cfm.status);
3478 BTIF_TRACE_DEBUG("DB [%02x] [%02x] [%02x] [%02x] [%02x] [%02x]",
3479 p_data->cch_open_cfm.bd_addr[0], p_data->cch_open_cfm.bd_addr[1],
3480 p_data->cch_open_cfm.bd_addr[2], p_data->cch_open_cfm.bd_addr[3],
3481 p_data->cch_open_cfm.bd_addr[4], p_data->cch_open_cfm.bd_addr[5]);
3483 if (p_data->cch_open_cfm.status == BTA_HL_STATUS_OK ||
3484 p_data->cch_open_cfm.status == BTA_HL_STATUS_DUPLICATE_CCH_OPEN)
3486 status = btif_hl_proc_cch_open_cfm(p_data);
3495 if (btif_hl_find_app_idx_using_app_id(p_data->cch_open_cfm.app_id, &app_idx))
3497 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
3498 if (btif_hl_find_mcl_idx(app_idx, p_data->cch_open_cfm.bd_addr, &mcl_idx))
3500 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
3501 pending_op = p_mcb->pcb.op;
3504 case BTIF_HL_PEND_DCH_OP_OPEN:
3505 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx);
3507 case BTIF_HL_PEND_DCH_OP_RECONNECT:
3508 case BTIF_HL_PEND_DCH_OP_DELETE_MDL:
3512 btif_hl_clean_mcl_cb(app_idx, mcl_idx);
3518 case BTA_HL_DCH_OPEN_CFM_EVT:
3519 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_OPEN_CFM_EVT");
3520 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_handle=0x%x status=%d ",
3521 p_data->dch_open_cfm.mcl_handle,
3522 p_data->dch_open_cfm.mdl_handle,
3523 p_data->dch_open_cfm.status);
3524 BTIF_TRACE_DEBUG("first_reliable =%d dch_mode=%d local_mdep_id=%d mdl_id=%d mtu=%d",
3525 p_data->dch_open_cfm.first_reliable,
3526 p_data->dch_open_cfm.dch_mode,
3527 p_data->dch_open_cfm.local_mdep_id,
3528 p_data->dch_open_cfm.mdl_id,
3529 p_data->dch_open_cfm.mtu);
3530 if (p_data->dch_open_cfm.status == BTA_HL_STATUS_OK)
3532 status = btif_hl_proc_dch_open_cfm(p_data);
3541 if (btif_hl_find_mcl_idx_using_handle(p_data->dch_open_cfm.mcl_handle,&app_idx, &mcl_idx))
3543 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
3544 pending_op = p_mcb->pcb.op;
3547 case BTIF_HL_PEND_DCH_OP_OPEN:
3548 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx);
3550 case BTIF_HL_PEND_DCH_OP_RECONNECT:
3551 case BTIF_HL_PEND_DCH_OP_DELETE_MDL:
3560 case BTA_HL_CCH_OPEN_IND_EVT:
3561 BTIF_TRACE_DEBUG("Rcv BTA_HL_CCH_OPEN_IND_EVT");
3562 BTIF_TRACE_DEBUG("app_handle=%d mcl_handle=%d",
3563 p_data->cch_open_ind.app_handle,
3564 p_data->cch_open_ind.mcl_handle);
3565 BTIF_TRACE_DEBUG("DB [%02x] [%02x] [%02x] [%02x] [%02x] [%02x]",
3566 p_data->cch_open_ind.bd_addr[0], p_data->cch_open_ind.bd_addr[1],
3567 p_data->cch_open_ind.bd_addr[2], p_data->cch_open_ind.bd_addr[3],
3568 p_data->cch_open_ind.bd_addr[4], p_data->cch_open_ind.bd_addr[5]);
3570 btif_hl_proc_cch_open_ind(p_data);
3573 case BTA_HL_DCH_CREATE_IND_EVT:
3574 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_CREATE_IND_EVT");
3575 BTIF_TRACE_DEBUG("mcl_handle=%d",
3576 p_data->dch_create_ind.mcl_handle );
3577 BTIF_TRACE_DEBUG("local_mdep_id =%d mdl_id=%d cfg=%d",
3578 p_data->dch_create_ind.local_mdep_id,
3579 p_data->dch_create_ind.mdl_id,
3580 p_data->dch_create_ind.cfg);
3581 btif_hl_proc_create_ind(p_data);
3584 case BTA_HL_DCH_OPEN_IND_EVT:
3585 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_OPEN_IND_EVT");
3586 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_handle=0x%x",
3587 p_data->dch_open_ind.mcl_handle,
3588 p_data->dch_open_ind.mdl_handle );
3589 BTIF_TRACE_DEBUG("first_reliable =%d dch_mode=%d local_mdep_id=%d mdl_id=%d mtu=%d",
3590 p_data->dch_open_ind.first_reliable,
3591 p_data->dch_open_ind.dch_mode,
3592 p_data->dch_open_ind.local_mdep_id,
3593 p_data->dch_open_ind.mdl_id,
3594 p_data->dch_open_ind.mtu);
3596 btif_hl_proc_dch_open_ind(p_data);
3599 case BTA_HL_DELETE_MDL_IND_EVT:
3600 BTIF_TRACE_DEBUG("Rcv BTA_HL_DELETE_MDL_IND_EVT");
3601 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_id=0x%x",
3602 p_data->delete_mdl_ind.mcl_handle,
3603 p_data->delete_mdl_ind.mdl_id);
3606 case BTA_HL_DELETE_MDL_CFM_EVT:
3607 BTIF_TRACE_DEBUG("Rcv BTA_HL_DELETE_MDL_CFM_EVT");
3608 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_id=0x%x status=%d",
3609 p_data->delete_mdl_cfm.mcl_handle,
3610 p_data->delete_mdl_cfm.mdl_id,
3611 p_data->delete_mdl_cfm.status);
3613 if (btif_hl_find_app_idx_using_deleted_mdl_id( p_data->delete_mdl_cfm.mdl_id,
3616 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
3617 btif_hl_send_destroyed_cb(p_acb);
3618 btif_hl_clean_delete_mdl(&p_acb->delete_mdl);
3622 case BTA_HL_DCH_RECONNECT_CFM_EVT:
3623 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_RECONNECT_CFM_EVT");
3624 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_handle=%d status=%d ",
3625 p_data->dch_reconnect_cfm.mcl_handle,
3626 p_data->dch_reconnect_cfm.mdl_handle,
3627 p_data->dch_reconnect_cfm.status);
3628 BTIF_TRACE_DEBUG("first_reliable =%d dch_mode=%d mdl_id=%d mtu=%d",
3629 p_data->dch_reconnect_cfm.first_reliable,
3630 p_data->dch_reconnect_cfm.dch_mode,
3631 p_data->dch_reconnect_cfm.mdl_id,
3632 p_data->dch_reconnect_cfm.mtu);
3635 if (p_data->dch_reconnect_cfm.status == BTA_HL_STATUS_OK)
3637 status = btif_hl_proc_dch_reconnect_cfm(p_data);
3646 if (btif_hl_find_mcl_idx_using_handle(p_data->dch_open_cfm.mcl_handle,&app_idx, &mcl_idx))
3648 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
3649 pending_op = p_mcb->pcb.op;
3652 case BTIF_HL_PEND_DCH_OP_OPEN:
3653 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx);
3655 case BTIF_HL_PEND_DCH_OP_RECONNECT:
3656 case BTIF_HL_PEND_DCH_OP_DELETE_MDL:
3665 case BTA_HL_CCH_CLOSE_CFM_EVT:
3666 BTIF_TRACE_DEBUG("Rcv BTA_HL_CCH_CLOSE_CFM_EVT");
3667 BTIF_TRACE_DEBUG("mcl_handle=%d status =%d",
3668 p_data->cch_close_cfm.mcl_handle,
3669 p_data->cch_close_cfm.status);
3670 if (p_data->cch_close_cfm.status == BTA_HL_STATUS_OK)
3672 btif_hl_proc_cch_close_cfm(p_data);
3676 case BTA_HL_CCH_CLOSE_IND_EVT:
3677 BTIF_TRACE_DEBUG("Rcv BTA_HL_CCH_CLOSE_IND_EVT");
3678 BTIF_TRACE_DEBUG("mcl_handle =%d intentional_close=%s",
3679 p_data->cch_close_ind.mcl_handle,
3680 (p_data->cch_close_ind.intentional?"Yes":"No"));
3682 btif_hl_proc_cch_close_ind(p_data);
3685 case BTA_HL_DCH_CLOSE_IND_EVT:
3686 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_CLOSE_IND_EVT");
3687 BTIF_TRACE_DEBUG("mdl_handle=%d intentional_close=%s",
3688 p_data->dch_close_ind.mdl_handle,
3689 (p_data->dch_close_ind.intentional?"Yes":"No") );
3691 btif_hl_proc_dch_close_ind(p_data);
3694 case BTA_HL_DCH_CLOSE_CFM_EVT:
3695 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_CLOSE_CFM_EVT");
3696 BTIF_TRACE_DEBUG("mdl_handle=%d status=%d ",
3697 p_data->dch_close_cfm.mdl_handle,
3698 p_data->dch_close_cfm.status);
3700 if (p_data->dch_close_cfm.status == BTA_HL_STATUS_OK)
3702 btif_hl_proc_dch_close_cfm(p_data);
3706 case BTA_HL_DCH_ECHO_TEST_CFM_EVT:
3707 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_ECHO_TEST_CFM_EVT");
3708 BTIF_TRACE_DEBUG("mcl_handle=%d status=%d",
3709 p_data->echo_test_cfm.mcl_handle,
3710 p_data->echo_test_cfm.status );
3715 case BTA_HL_DCH_RECONNECT_IND_EVT:
3716 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_RECONNECT_IND_EVT");
3718 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_handle=5d",
3719 p_data->dch_reconnect_ind.mcl_handle,
3720 p_data->dch_reconnect_ind.mdl_handle );
3721 BTIF_TRACE_DEBUG("first_reliable =%d dch_mode=%d mdl_id=%d mtu=%d",
3722 p_data->dch_reconnect_ind.first_reliable,
3723 p_data->dch_reconnect_ind.dch_mode,
3724 p_data->dch_reconnect_ind.mdl_id,
3725 p_data->dch_reconnect_ind.mtu);
3727 btif_hl_proc_dch_reconnect_ind(p_data);
3730 case BTA_HL_CONG_CHG_IND_EVT:
3731 BTIF_TRACE_DEBUG("Rcv BTA_HL_CONG_CHG_IND_EVT");
3732 BTIF_TRACE_DEBUG("mdl_handle=%d cong =%d",
3733 p_data->dch_cong_ind.mdl_handle,
3734 p_data->dch_cong_ind.cong);
3735 btif_hl_proc_dch_cong_ind(p_data);
3738 case BTA_HL_DCH_ABORT_IND_EVT:
3739 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_ABORT_IND_EVT");
3740 BTIF_TRACE_DEBUG("mcl_handle=%d",
3741 p_data->dch_abort_ind.mcl_handle );
3742 btif_hl_proc_abort_ind(p_data->dch_abort_ind.mcl_handle);
3744 case BTA_HL_DCH_ABORT_CFM_EVT:
3745 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_ABORT_CFM_EVT");
3746 BTIF_TRACE_DEBUG("mcl_handle=%d status =%d",
3747 p_data->dch_abort_cfm.mcl_handle,
3748 p_data->dch_abort_cfm.status);
3749 if (p_data->dch_abort_cfm.status == BTA_HL_STATUS_OK)
3751 btif_hl_proc_abort_cfm(p_data->dch_abort_ind.mcl_handle);
3755 case BTA_HL_DCH_SEND_DATA_CFM_EVT:
3756 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_SEND_DATA_CFM_EVT");
3757 BTIF_TRACE_DEBUG("mdl_handle=0x%x status =%d",
3758 p_data->dch_send_data_cfm.mdl_handle,
3759 p_data->dch_send_data_cfm.status);
3760 btif_hl_proc_send_data_cfm(p_data->dch_send_data_cfm.mdl_handle,
3761 p_data->dch_send_data_cfm.status);
3764 case BTA_HL_DCH_RCV_DATA_IND_EVT:
3765 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_RCV_DATA_IND_EVT");
3766 BTIF_TRACE_DEBUG("mdl_handle=0x%x ",
3767 p_data->dch_rcv_data_ind.mdl_handle);
3768 /* do nothing here */
3772 BTIF_TRACE_DEBUG("Unknown Event (0x%02x)...", event);
3777 /*******************************************************************************
3779 ** Function btif_hl_cback
3781 ** Description Callback function for HL events
3785 *******************************************************************************/
3786 static void btif_hl_cback(tBTA_HL_EVT event, tBTA_HL *p_data){
3789 BTIF_TRACE_DEBUG("%s event %d", __FUNCTION__, event);
3790 btif_hl_display_calling_process_name();
3793 case BTA_HL_REGISTER_CFM_EVT:
3794 param_len = sizeof(tBTA_HL_REGISTER_CFM);
3796 case BTA_HL_SDP_INFO_IND_EVT:
3797 param_len = sizeof(tBTA_HL_SDP_INFO_IND);
3799 case BTA_HL_DEREGISTER_CFM_EVT:
3800 param_len = sizeof(tBTA_HL_DEREGISTER_CFM);
3802 case BTA_HL_SDP_QUERY_CFM_EVT:
3803 param_len = sizeof(tBTA_HL_SDP_QUERY_CFM);
3805 case BTA_HL_CCH_OPEN_CFM_EVT:
3806 param_len = sizeof(tBTA_HL_CCH_OPEN_CFM);
3808 case BTA_HL_DCH_OPEN_CFM_EVT:
3809 param_len = sizeof(tBTA_HL_DCH_OPEN_CFM);
3811 case BTA_HL_CCH_OPEN_IND_EVT:
3812 param_len = sizeof(tBTA_HL_CCH_OPEN_IND);
3814 case BTA_HL_DCH_CREATE_IND_EVT:
3815 param_len = sizeof(tBTA_HL_DCH_CREATE_IND);
3817 case BTA_HL_DCH_OPEN_IND_EVT:
3818 param_len = sizeof(tBTA_HL_DCH_OPEN_IND);
3820 case BTA_HL_DELETE_MDL_IND_EVT:
3821 param_len = sizeof(tBTA_HL_MDL_IND);
3823 case BTA_HL_DELETE_MDL_CFM_EVT:
3824 param_len = sizeof(tBTA_HL_MDL_CFM);
3826 case BTA_HL_DCH_RECONNECT_CFM_EVT:
3827 param_len = sizeof(tBTA_HL_DCH_OPEN_CFM);
3829 case BTA_HL_CCH_CLOSE_CFM_EVT:
3830 param_len = sizeof(tBTA_HL_MCL_CFM);
3832 case BTA_HL_CCH_CLOSE_IND_EVT:
3833 param_len = sizeof(tBTA_HL_CCH_CLOSE_IND);
3835 case BTA_HL_DCH_CLOSE_IND_EVT:
3836 param_len = sizeof(tBTA_HL_DCH_CLOSE_IND);
3838 case BTA_HL_DCH_CLOSE_CFM_EVT:
3839 param_len = sizeof(tBTA_HL_MDL_CFM);
3841 case BTA_HL_DCH_ECHO_TEST_CFM_EVT:
3842 param_len = sizeof(tBTA_HL_MCL_CFM);
3844 case BTA_HL_DCH_RECONNECT_IND_EVT:
3845 param_len = sizeof(tBTA_HL_DCH_OPEN_IND);
3847 case BTA_HL_CONG_CHG_IND_EVT:
3848 param_len = sizeof(tBTA_HL_DCH_CONG_IND);
3850 case BTA_HL_DCH_ABORT_IND_EVT:
3851 param_len = sizeof(tBTA_HL_MCL_IND);
3853 case BTA_HL_DCH_ABORT_CFM_EVT:
3854 param_len = sizeof(tBTA_HL_MCL_CFM);
3856 case BTA_HL_DCH_SEND_DATA_CFM_EVT:
3857 param_len = sizeof(tBTA_HL_MDL_CFM);
3859 case BTA_HL_DCH_RCV_DATA_IND_EVT:
3860 param_len = sizeof(tBTA_HL_MDL_IND);
3863 param_len = sizeof(tBTA_HL_MDL_IND);
3866 status = btif_transfer_context(btif_hl_upstreams_evt, (uint16_t)event, (void*)p_data, param_len, NULL);
3868 /* catch any failed context transfers */
3869 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
3872 /*******************************************************************************
3874 ** Function btif_hl_upstreams_ctrl_evt
3876 ** Description Callback function for HL control events in the BTIF task context
3880 *******************************************************************************/
3881 static void btif_hl_upstreams_ctrl_evt(UINT16 event, char* p_param){
3882 tBTA_HL_CTRL *p_data = (tBTA_HL_CTRL *) p_param;
3884 tBTA_HL_REG_PARAM reg_param;
3885 btif_hl_app_cb_t *p_acb;
3887 BTIF_TRACE_DEBUG("%s event %d", __FUNCTION__, event);
3888 btif_hl_display_calling_process_name();
3892 case BTA_HL_CTRL_ENABLE_CFM_EVT:
3893 BTIF_TRACE_DEBUG("Rcv BTA_HL_CTRL_ENABLE_CFM_EVT");
3894 BTIF_TRACE_DEBUG("status=%d", p_data->enable_cfm.status);
3896 if (p_data->enable_cfm.status == BTA_HL_STATUS_OK)
3898 btif_hl_set_state(BTIF_HL_STATE_ENABLED);
3901 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
3903 p_acb = BTIF_HL_GET_APP_CB_PTR(i);
3904 if (p_acb->in_use && p_acb->reg_pending)
3906 p_acb->reg_pending = FALSE;
3907 reg_param.dev_type = p_acb->dev_type;
3908 reg_param.sec_mask = BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT;
3909 reg_param.p_srv_name = p_acb->srv_name;
3910 reg_param.p_srv_desp = p_acb->srv_desp;
3911 reg_param.p_provider_name = p_acb->provider_name;
3913 BTIF_TRACE_DEBUG("Register pending app_id=%d", p_acb->app_id);
3914 btif_hl_proc_reg_request (i, p_acb->app_id, ®_param, btif_hl_cback);
3920 case BTA_HL_CTRL_DISABLE_CFM_EVT:
3921 BTIF_TRACE_DEBUG("Rcv BTA_HL_CTRL_DISABLE_CFM_EVT");
3922 BTIF_TRACE_DEBUG("status=%d",
3923 p_data->disable_cfm.status);
3925 if (p_data->disable_cfm.status == BTA_HL_STATUS_OK)
3927 memset(p_btif_hl_cb, 0, sizeof(btif_hl_cb_t));
3928 btif_hl_set_state(BTIF_HL_STATE_DISABLED);
3937 /*******************************************************************************
3939 ** Function btif_hl_ctrl_cback
3941 ** Description Callback function for HL control events
3945 *******************************************************************************/
3946 static void btif_hl_ctrl_cback(tBTA_HL_CTRL_EVT event, tBTA_HL_CTRL *p_data){
3950 BTIF_TRACE_DEBUG("%s event %d", __FUNCTION__, event);
3951 btif_hl_display_calling_process_name();
3955 case BTA_HL_CTRL_ENABLE_CFM_EVT:
3956 case BTA_HL_CTRL_DISABLE_CFM_EVT:
3957 param_len = sizeof(tBTA_HL_CTRL_ENABLE_DISABLE);
3963 status = btif_transfer_context(btif_hl_upstreams_ctrl_evt, (uint16_t)event, (void*)p_data, param_len, NULL);
3964 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
3966 /*******************************************************************************
3968 ** Function connect_channel
3970 ** Description connect a data channel
3972 ** Returns bt_status_t
3974 *******************************************************************************/
3975 static bt_status_t connect_channel(int app_id, bt_bdaddr_t *bd_addr, int mdep_cfg_index, int *channel_id){
3976 UINT8 app_idx, mcl_idx;
3977 btif_hl_app_cb_t *p_acb = NULL;
3978 btif_hl_pending_chan_cb_t *p_pcb = NULL;
3979 btif_hl_mcl_cb_t *p_mcb=NULL;
3980 bt_status_t status = BT_STATUS_SUCCESS;
3981 tBTA_HL_DCH_OPEN_PARAM dch_open;
3986 BTIF_TRACE_EVENT("%s", __FUNCTION__);
3987 btif_hl_display_calling_process_name();
3992 bda[i] = (UINT8) bd_addr->address[i];
3994 if (btif_hl_find_app_idx(((UINT8)app_id), &app_idx))
3996 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
3997 if (btif_hl_find_mcl_idx(app_idx, bda , &mcl_idx))
3999 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
4000 if (p_mcb->is_connected)
4002 dch_open.ctrl_psm = p_mcb->ctrl_psm;
4003 dch_open.local_mdep_id = p_acb->sup_feature.mdep[mdep_cfg_index].mdep_id;
4004 BTIF_TRACE_DEBUG("connect_channel: app_idx =%d, mdep_cfg_indx =%d, mdep_id =%d app_id= %d", app_idx,
4005 mdep_cfg_index, dch_open.local_mdep_id, app_id);
4006 if (btif_hl_find_peer_mdep_id(p_acb->app_id, p_mcb->bd_addr,
4007 p_acb->sup_feature.mdep[mdep_cfg_index].mdep_cfg.mdep_role,
4008 p_acb->sup_feature.mdep[mdep_cfg_index].mdep_cfg.data_cfg[0].data_type, &dch_open.peer_mdep_id ))
4010 dch_open.local_cfg = p_acb->channel_type[mdep_cfg_index];
4011 if ((p_acb->sup_feature.mdep[mdep_cfg_index].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
4012 && !btif_hl_is_the_first_reliable_existed(app_idx,mcl_idx))
4014 dch_open.local_cfg = BTA_HL_DCH_CFG_RELIABLE;
4016 dch_open.sec_mask = (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT);
4018 if( !btif_hl_dch_open(p_acb->app_id, bda, &dch_open,
4019 mdep_cfg_index, BTIF_HL_PEND_DCH_OP_OPEN, channel_id ))
4021 status = BT_STATUS_FAIL;
4022 BTIF_TRACE_EVENT("%s loc0 status = BT_STATUS_FAIL", __FUNCTION__);
4027 p_mcb->cch_oper = BTIF_HL_CCH_OP_MDEP_FILTERING;
4029 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
4030 p_pcb->in_use = TRUE;
4031 p_pcb->mdep_cfg_idx = mdep_cfg_index;
4032 memcpy(p_pcb->bd_addr, bda, sizeof(BD_ADDR));
4033 p_pcb->op = BTIF_HL_PEND_DCH_OP_OPEN;
4034 BTA_HlSdpQuery(app_id,p_acb->app_handle, bda);
4039 status = BT_STATUS_FAIL;
4044 p_acb->filter.num_elems =1;
4045 p_acb->filter.elem[0].data_type = p_acb->sup_feature.mdep[mdep_cfg_index].mdep_cfg.data_cfg[mdep_cfg_index].data_type;
4046 if (p_acb->sup_feature.mdep[mdep_cfg_index].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SINK)
4047 p_acb->filter.elem[0].peer_mdep_role = BTA_HL_MDEP_ROLE_SOURCE;
4049 p_acb->filter.elem[0].peer_mdep_role = BTA_HL_MDEP_ROLE_SINK;
4051 if ( !btif_hl_cch_open(p_acb->app_id, bda, 0, mdep_cfg_index,
4052 BTIF_HL_PEND_DCH_OP_OPEN,
4055 status = BT_STATUS_FAIL;
4061 status = BT_STATUS_FAIL;
4064 BTIF_TRACE_DEBUG("%s status=%d channel_id=0x%08x", __FUNCTION__, status, *channel_id);
4068 /*******************************************************************************
4070 ** Function destroy_channel
4072 ** Description destroy a data channel
4074 ** Returns bt_status_t
4076 *******************************************************************************/
4077 static bt_status_t destroy_channel(int channel_id){
4078 UINT8 app_idx, mcl_idx, mdl_idx, mdl_cfg_idx, app_id, mdep_cfg_idx = 0;
4079 bt_status_t status = BT_STATUS_SUCCESS;
4080 btif_hl_mdl_cfg_t *p_mdl;
4081 btif_hl_mcl_cb_t *p_mcb;
4082 btif_hl_mdl_cb_t *p_dcb;
4083 btif_hl_app_cb_t *p_acb;
4086 BTIF_TRACE_EVENT("%s channel_id=0x%08x", __FUNCTION__, channel_id);
4087 btif_hl_display_calling_process_name();
4090 if (btif_hl_if_channel_setup_pending(channel_id, &app_idx, &mcl_idx))
4092 btif_hl_dch_abort(app_idx, mcl_idx);
4096 if (btif_hl_find_mdl_cfg_idx_using_channel_id(channel_id, &app_idx, &mdl_cfg_idx))
4097 // if(btif_hl_find_mdl_idx_using_channel_id(channel_id, &app_idx,&mcl_idx, &mdl_idx))
4099 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
4100 if (!p_acb->delete_mdl.active)
4102 p_mdl =BTIF_HL_GET_MDL_CFG_PTR(app_idx, mdl_cfg_idx);
4103 p_acb->delete_mdl.active = TRUE;
4104 p_acb->delete_mdl.mdl_id = p_mdl->base.mdl_id;
4105 p_acb->delete_mdl.channel_id = channel_id;
4106 p_acb->delete_mdl.mdep_cfg_idx = p_mdl->extra.mdep_cfg_idx;
4107 memcpy(p_acb->delete_mdl.bd_addr, p_mdl->base.peer_bd_addr,sizeof(BD_ADDR));
4109 if (btif_hl_find_mcl_idx(app_idx, p_mdl->base.peer_bd_addr, &mcl_idx))
4111 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
4112 if (p_mcb->is_connected)
4114 BTIF_TRACE_DEBUG("calling BTA_HlDeleteMdl mdl_id=%d",p_acb->delete_mdl.mdl_id );
4115 BTA_HlDeleteMdl(p_mcb->mcl_handle, p_acb->delete_mdl.mdl_id);
4119 status = BT_STATUS_FAIL;
4124 BTIF_TRACE_DEBUG("btif_hl_delete_mdl calling btif_hl_cch_open" );
4125 mdep_cfg_idx = p_mdl->extra.mdep_cfg_idx;
4126 p_acb->filter.num_elems =1;
4127 p_acb->filter.elem[0].data_type = p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg.data_cfg[mdep_cfg_idx].data_type;
4128 if (p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SINK)
4129 p_acb->filter.elem[0].peer_mdep_role = BTA_HL_MDEP_ROLE_SOURCE;
4131 p_acb->filter.elem[0].peer_mdep_role = BTA_HL_MDEP_ROLE_SINK;
4132 if (btif_hl_cch_open(p_acb->app_id, p_acb->delete_mdl.bd_addr, 0,
4134 BTIF_HL_PEND_DCH_OP_DELETE_MDL, NULL))
4136 status = BT_STATUS_FAIL;
4140 if ( status == BT_STATUS_FAIL)
4143 btif_hl_clean_delete_mdl(&p_acb->delete_mdl);
4148 status = BT_STATUS_BUSY;
4153 status = BT_STATUS_FAIL;
4159 /*******************************************************************************
4161 ** Function unregister_application
4163 ** Description unregister an HDP application
4165 ** Returns bt_status_t
4167 *******************************************************************************/
4168 static bt_status_t unregister_application(int app_id){
4169 btif_hl_app_cb_t *p_acb;
4172 bt_status_t status = BT_STATUS_SUCCESS;
4173 btif_hl_evt_cb_t evt_param;
4176 BTIF_TRACE_EVENT("%s app_id=%d", __FUNCTION__, app_id);
4177 btif_hl_display_calling_process_name();
4179 if (btif_hl_find_app_idx(((UINT8)app_id), &app_idx))
4181 evt_param.unreg.app_idx = app_idx;
4182 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
4184 len = sizeof(btif_hl_unreg_t);
4185 status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_UNREG_APP,
4186 (char*) &evt_param, len, NULL);
4187 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
4191 status = BT_STATUS_FAIL;
4194 BTIF_TRACE_DEBUG("de-reg return status=%d", status);
4197 /*******************************************************************************
4199 ** Function register_application
4201 ** Description register an HDP application
4203 ** Returns bt_status_t
4205 *******************************************************************************/
4206 static bt_status_t register_application(bthl_reg_param_t *p_reg_param, int *app_id){
4207 btif_hl_app_cb_t *p_acb;
4208 tBTA_HL_SUP_FEATURE *p_sup;
4209 tBTA_HL_MDEP_CFG *p_cfg;
4210 tBTA_HL_MDEP_DATA_TYPE_CFG *p_data;
4211 UINT8 app_idx=0, i=0, pending_reg_idx=0;
4212 bthl_mdep_cfg_t *p_mdep_cfg;
4213 bt_status_t status = BT_STATUS_SUCCESS;
4214 btif_hl_evt_cb_t evt_param;
4218 BTIF_TRACE_EVENT("%s", __FUNCTION__);
4219 btif_hl_display_calling_process_name();
4221 if (btif_hl_get_state() == BTIF_HL_STATE_DISABLED)
4224 btif_hl_set_state(BTIF_HL_STATE_ENABLING);
4225 BTA_HlEnable(btif_hl_ctrl_cback);
4228 if (!btif_hl_find_avail_app_idx(&app_idx))
4230 BTIF_TRACE_ERROR("Unable to allocate a new application control block");
4231 return BT_STATUS_FAIL;
4234 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
4235 p_acb->in_use = TRUE;
4238 p_acb->app_id = btif_hl_get_next_app_id();
4240 if (p_reg_param->application_name != NULL )
4241 strncpy(p_acb->application_name, p_reg_param->application_name, BTIF_HL_APPLICATION_NAME_LEN);
4243 if (p_reg_param->provider_name != NULL )
4244 strncpy(p_acb->provider_name, p_reg_param->provider_name, BTA_PROVIDER_NAME_LEN);
4246 if (p_reg_param->srv_name != NULL )
4247 strncpy(p_acb->srv_name, p_reg_param->srv_name, BTA_SERVICE_NAME_LEN);
4249 if (p_reg_param->srv_desp != NULL )
4250 strncpy(p_acb->srv_desp, p_reg_param->srv_desp, BTA_SERVICE_DESP_LEN);
4252 p_sup = &p_acb->sup_feature;
4253 p_sup->advertize_source_sdp = TRUE;
4254 p_sup->echo_cfg.max_rx_apdu_size = BTIF_HL_ECHO_MAX_TX_RX_APDU_SIZE;
4255 p_sup->echo_cfg.max_tx_apdu_size = BTIF_HL_ECHO_MAX_TX_RX_APDU_SIZE;
4256 p_sup->num_of_mdeps = p_reg_param->number_of_mdeps;
4258 for (i=0, p_mdep_cfg = p_reg_param->mdep_cfg ; i< p_sup->num_of_mdeps; i++, p_mdep_cfg++ )
4260 p_cfg = &p_sup->mdep[i].mdep_cfg;
4261 p_cfg->num_of_mdep_data_types = 1;
4262 p_data = &p_cfg->data_cfg[0];
4264 if ( !btif_hl_get_bta_mdep_role(p_mdep_cfg->mdep_role, &(p_cfg->mdep_role)))
4266 BTIF_TRACE_ERROR("Invalid mdep_role=%d", p_mdep_cfg->mdep_role);
4267 status = BT_STATUS_FAIL;
4272 if (p_cfg->mdep_role == BTA_HL_MDEP_ROLE_SINK )
4273 p_sup->app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SINK;
4275 p_sup->app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SOURCE;
4277 if ( (p_sup->app_role_mask & BTA_HL_MDEP_ROLE_MASK_SINK) &&
4278 (p_sup->app_role_mask & BTA_HL_MDEP_ROLE_MASK_SINK) )
4280 p_acb->dev_type = BTA_HL_DEVICE_TYPE_DUAL;
4282 else if ( p_sup->app_role_mask & BTA_HL_MDEP_ROLE_MASK_SINK )
4283 p_acb->dev_type = BTA_HL_DEVICE_TYPE_SINK;
4286 p_acb->dev_type = BTA_HL_DEVICE_TYPE_SOURCE;
4288 p_data->data_type = (UINT16) p_mdep_cfg->data_type;
4289 p_data->max_rx_apdu_size = btif_hl_get_max_rx_apdu_size(p_cfg->mdep_role, p_data->data_type);
4290 p_data->max_tx_apdu_size = btif_hl_get_max_tx_apdu_size(p_cfg->mdep_role, p_data->data_type);
4292 if (p_mdep_cfg->mdep_description != NULL )
4293 strncpy(p_data->desp, p_mdep_cfg->mdep_description, BTA_SERVICE_DESP_LEN);
4295 if ( !btif_hl_get_bta_channel_type(p_mdep_cfg->channel_type, &(p_acb->channel_type[i])))
4297 BTIF_TRACE_ERROR("Invalid channel_type=%d", p_mdep_cfg->channel_type);
4298 status = BT_STATUS_FAIL;
4304 if (status == BT_STATUS_SUCCESS)
4306 *app_id = (int) p_acb->app_id;
4307 evt_param.reg.app_idx = app_idx;
4308 len = sizeof(btif_hl_reg_t);
4309 p_acb->reg_pending = TRUE;
4311 BTIF_TRACE_DEBUG("calling btif_transfer_context status=%d app_id=%d", status, *app_id);
4312 status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_REG_APP,
4313 (char*) &evt_param, len, NULL);
4314 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
4319 btif_hl_free_app_idx(app_idx);
4322 BTIF_TRACE_DEBUG("register_application status=%d app_id=%d", status, *app_id);
4326 /*******************************************************************************
4328 ** Function btif_hl_save_mdl_cfg
4330 ** Description Save the MDL configuration
4334 *******************************************************************************/
4335 BOOLEAN btif_hl_save_mdl_cfg(UINT8 mdep_id, UINT8 item_idx,
4336 tBTA_HL_MDL_CFG *p_mdl_cfg){
4337 btif_hl_mdl_cfg_t *p_mdl=NULL;
4338 BOOLEAN success = FALSE;
4339 btif_hl_app_cb_t *p_acb;
4340 btif_hl_mcl_cb_t *p_mcb;
4341 UINT8 app_idx, mcl_idx, mdl_idx, len;
4342 bt_status_t bt_status;
4343 btif_hl_evt_cb_t evt_param;
4346 BTIF_TRACE_DEBUG("%s mdep_id=%d item_idx=%d, local_mdep_id=%d mdl_id=0x%x dch_mode=%d",
4347 __FUNCTION__, mdep_id, item_idx, p_mdl_cfg->local_mdep_id,
4348 p_mdl_cfg->mdl_id, p_mdl_cfg->dch_mode );
4350 if(btif_hl_find_app_idx_using_mdepId(mdep_id,&app_idx))
4352 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
4353 p_mdl = BTIF_HL_GET_MDL_CFG_PTR(app_idx, item_idx);
4354 p_channel_id = BTIF_HL_GET_MDL_CFG_CHANNEL_ID_PTR(app_idx, item_idx);
4357 memcpy(&p_mdl->base, p_mdl_cfg, sizeof(tBTA_HL_MDL_CFG));
4358 if (btif_hl_find_mcl_idx(app_idx, p_mdl->base.peer_bd_addr , &mcl_idx))
4360 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
4361 if (p_mcb->pcb.in_use)
4362 *p_channel_id = p_mcb->pcb.channel_id;
4364 *p_channel_id = btif_hl_get_next_channel_id(p_acb->app_id);
4365 p_mdl->extra.mdep_cfg_idx = p_mcb->pcb.mdep_cfg_idx;
4366 p_mdl->extra.data_type = p_acb->sup_feature.mdep[p_mcb->pcb.mdep_cfg_idx].mdep_cfg.data_cfg[0].data_type;
4368 if (!btif_hl_find_peer_mdep_id(p_acb->app_id, p_mcb->bd_addr,
4369 p_acb->sup_feature.mdep[p_mcb->pcb.mdep_cfg_idx].mdep_cfg.mdep_role,
4370 p_acb->sup_feature.mdep[p_mcb->pcb.mdep_cfg_idx].mdep_cfg.data_cfg[0].data_type,
4371 &p_mdl->extra.peer_mdep_id))
4373 p_mdl->extra.peer_mdep_id = BTA_HL_INVALID_MDEP_ID;
4375 BTIF_TRACE_DEBUG("%s app_idx=%d item_idx=%d mld_id=0x%x",
4376 __FUNCTION__, app_idx, item_idx, p_mdl->base.mdl_id);
4377 evt_param.update_mdl.app_idx = app_idx;
4378 len = sizeof(btif_hl_update_mdl_t);
4379 BTIF_TRACE_DEBUG("send BTIF_HL_UPDATE_MDL event app_idx=%d ",app_idx);
4380 if ((bt_status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_UPDATE_MDL,
4381 (char*) &evt_param, len, NULL)) == BT_STATUS_SUCCESS)
4385 ASSERTC(bt_status == BT_STATUS_SUCCESS, "context transfer failed", bt_status);
4389 BTIF_TRACE_DEBUG("%s success=%d ",__FUNCTION__, success );
4394 /*******************************************************************************
4396 ** Function btif_hl_delete_mdl_cfg
4398 ** Description Delete the MDL configuration
4402 *******************************************************************************/
4403 BOOLEAN btif_hl_delete_mdl_cfg(UINT8 mdep_id, UINT8 item_idx){
4404 btif_hl_mdl_cfg_t *p_mdl=NULL;
4405 BOOLEAN success = FALSE;
4406 btif_hl_app_cb_t *p_acb;
4408 bt_status_t bt_status;
4409 btif_hl_evt_cb_t evt_param;
4411 if(btif_hl_find_app_idx_using_mdepId(mdep_id,&app_idx))
4414 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
4416 p_mdl = BTIF_HL_GET_MDL_CFG_PTR(app_idx, item_idx);
4419 memset(p_mdl, 0, sizeof(btif_hl_mdl_cfg_t));
4420 evt_param.update_mdl.app_idx = app_idx;
4421 len = sizeof(btif_hl_update_mdl_t);
4422 BTIF_TRACE_DEBUG("send BTIF_HL_UPDATE_MDL event app_idx=%d ",app_idx);
4423 if ((bt_status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_UPDATE_MDL,
4424 (char*) &evt_param, len, NULL)) == BT_STATUS_SUCCESS)
4428 ASSERTC(bt_status == BT_STATUS_SUCCESS, "context transfer failed", bt_status);
4432 BTIF_TRACE_DEBUG("%s success=%d ",__FUNCTION__, success );
4436 /*******************************************************************************
4440 ** Description initializes the hl interface
4442 ** Returns bt_status_t
4444 *******************************************************************************/
4445 static bt_status_t init( bthl_callbacks_t* callbacks ){
4446 bt_status_t status = BT_STATUS_SUCCESS;
4448 BTIF_TRACE_EVENT("%s", __FUNCTION__);
4449 btif_hl_display_calling_process_name();
4450 bt_hl_callbacks_cb = *callbacks;
4451 bt_hl_callbacks = &bt_hl_callbacks_cb;
4452 btif_hl_soc_thread_init();
4456 /*******************************************************************************
4460 ** Description Closes the HL interface
4464 *******************************************************************************/
4465 static void cleanup( void ){
4466 BTIF_TRACE_EVENT("%s", __FUNCTION__);
4467 btif_hl_display_calling_process_name();
4468 if (bt_hl_callbacks)
4470 btif_disable_service(BTA_HDP_SERVICE_ID);
4471 bt_hl_callbacks = NULL;
4476 btif_hl_close_select_thread();
4479 static const bthl_interface_t bthlInterface = {
4480 sizeof(bthl_interface_t),
4482 register_application,
4483 unregister_application,
4490 /*******************************************************************************
4492 ** Function btif_hl_get_interface
4494 ** Description Get the hl callback interface
4496 ** Returns bthf_interface_t
4498 *******************************************************************************/
4499 const bthl_interface_t *btif_hl_get_interface(){
4500 BTIF_TRACE_EVENT("%s", __FUNCTION__);
4501 return &bthlInterface;
4504 /*******************************************************************************
4506 ** Function btif_hl_update_maxfd
4508 ** Description Update the max fd if the input fd is greater than the current max fd
4512 *******************************************************************************/
4513 int btif_hl_update_maxfd( int max_org_s){
4514 btif_hl_soc_cb_t *p_scb = NULL;
4517 BTIF_TRACE_DEBUG("btif_hl_update_maxfd max_org_s= %d", max_org_s);
4520 if (!GKI_queue_is_empty(&soc_queue))
4522 p_scb = (btif_hl_soc_cb_t *)GKI_getfirst((void *)&soc_queue);
4523 if (maxfd < p_scb->max_s)
4525 maxfd = p_scb->max_s;
4526 BTIF_TRACE_DEBUG("btif_hl_update_maxfd 1 maxfd=%d", maxfd);
4528 while (p_scb != NULL)
4530 if (maxfd < p_scb->max_s)
4532 maxfd = p_scb->max_s;
4533 BTIF_TRACE_DEBUG("btif_hl_update_maxfd 2 maxfd=%d", maxfd);
4535 p_scb = (btif_hl_soc_cb_t *)GKI_getnext((void *)p_scb );
4539 BTIF_TRACE_DEBUG("btif_hl_update_maxfd final *p_max_s=%d", maxfd);
4542 /*******************************************************************************
4544 ** Function btif_hl_get_socket_state
4546 ** Description get socket state
4548 ** Returns btif_hl_soc_state_t
4550 *******************************************************************************/
4551 btif_hl_soc_state_t btif_hl_get_socket_state(btif_hl_soc_cb_t *p_scb){
4552 BTIF_TRACE_DEBUG("btif_hl_get_socket_state state=%d", p_scb->state);
4553 return p_scb->state;
4555 /*******************************************************************************
4557 ** Function btif_hl_set_socket_state
4559 ** Description set socket state
4563 *******************************************************************************/
4564 void btif_hl_set_socket_state(btif_hl_soc_cb_t *p_scb, btif_hl_soc_state_t new_state){
4565 BTIF_TRACE_DEBUG("btif_hl_set_socket_state %d---->%d", p_scb->state, new_state);
4566 p_scb->state = new_state;
4568 /*******************************************************************************
4570 ** Function btif_hl_release_mcl_sockets
4572 ** Description Release all sockets on the MCL
4576 *******************************************************************************/
4577 void btif_hl_release_mcl_sockets(UINT8 app_idx, UINT8 mcl_idx){
4578 btif_hl_soc_cb_t *p_scb = NULL;
4580 btif_hl_mdl_cb_t *p_dcb;
4581 BOOLEAN found= FALSE;
4582 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
4583 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
4585 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, i);
4586 if (p_dcb && p_dcb->in_use && p_dcb->p_scb)
4588 BTIF_TRACE_DEBUG("found socket for app_idx=%d mcl_id=%d, mdl_idx=%d", app_idx, mcl_idx, i);
4589 btif_hl_set_socket_state (p_dcb->p_scb, BTIF_HL_SOC_STATE_W4_REL);
4590 p_dcb->p_scb = NULL;
4595 btif_hl_select_close_connected();
4597 /*******************************************************************************
4599 ** Function btif_hl_release_socket
4601 ** Description release a specified socket
4605 *******************************************************************************/
4606 void btif_hl_release_socket(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx){
4607 btif_hl_soc_cb_t *p_scb = NULL;
4608 btif_hl_mdl_cb_t *p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
4610 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
4611 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d mdl_idx=%d", app_idx, mcl_idx, mdl_idx );
4613 if (p_dcb && p_dcb->p_scb)
4615 p_scb = p_dcb->p_scb;
4616 btif_hl_set_socket_state(p_scb, BTIF_HL_SOC_STATE_W4_REL);
4617 p_dcb->p_scb = NULL;
4618 btif_hl_select_close_connected();
4621 /*******************************************************************************
4623 ** Function btif_hl_create_socket
4625 ** Description create a socket
4629 *******************************************************************************/
4630 BOOLEAN btif_hl_create_socket(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx){
4631 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
4632 btif_hl_mdl_cb_t *p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
4633 btif_hl_soc_cb_t *p_scb = NULL;
4635 BOOLEAN status = FALSE;
4637 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
4639 if (p_dcb && ((p_scb = (btif_hl_soc_cb_t *)GKI_getbuf((UINT16)sizeof(btif_hl_soc_cb_t)))!=NULL))
4641 if (socketpair(AF_UNIX, SOCK_STREAM, 0, p_scb->socket_id) >= 0)
4643 BTIF_TRACE_DEBUG("socket id[0]=%d id[1]=%d",p_scb->socket_id[0], p_scb->socket_id[1] );
4644 p_dcb->p_scb = p_scb;
4645 p_scb->app_idx = app_idx;
4646 p_scb->mcl_idx = mcl_idx;
4647 p_scb->mdl_idx = mdl_idx;
4648 p_scb->channel_id = p_dcb->channel_id;
4649 p_scb->mdep_cfg_idx = p_dcb->local_mdep_cfg_idx;
4650 memcpy(p_scb->bd_addr, p_mcb->bd_addr,sizeof(BD_ADDR));
4651 btif_hl_set_socket_state(p_scb, BTIF_HL_SOC_STATE_W4_ADD);
4652 p_scb->max_s = p_scb->socket_id[1];
4653 GKI_enqueue(&soc_queue, (void *) p_scb);
4654 btif_hl_select_wakeup();
4660 btif_hl_free_buf((void **)&p_scb);
4664 BTIF_TRACE_DEBUG("%s status=%d", __FUNCTION__, status);
4667 /*******************************************************************************
4669 ** Function btif_hl_add_socket_to_set
4671 ** Description Add a socket
4675 *******************************************************************************/
4676 void btif_hl_add_socket_to_set( fd_set *p_org_set){
4677 btif_hl_soc_cb_t *p_scb = NULL;
4678 btif_hl_mdl_cb_t *p_dcb = NULL;
4679 btif_hl_mcl_cb_t *p_mcb = NULL;
4680 btif_hl_app_cb_t *p_acb = NULL;
4681 btif_hl_evt_cb_t evt_param;
4685 BTIF_TRACE_DEBUG("entering %s",__FUNCTION__);
4687 if (!GKI_queue_is_empty(&soc_queue))
4689 p_scb = (btif_hl_soc_cb_t *)GKI_getfirst((void *)&soc_queue);
4690 BTIF_TRACE_DEBUG("btif_hl_add_socket_to_set first p_scb=0x%x", p_scb);
4691 while (p_scb != NULL)
4693 if (btif_hl_get_socket_state(p_scb) == BTIF_HL_SOC_STATE_W4_ADD)
4695 btif_hl_set_socket_state(p_scb, BTIF_HL_SOC_STATE_W4_READ);
4696 FD_SET(p_scb->socket_id[1], p_org_set);
4697 BTIF_TRACE_DEBUG("found and set socket_id=%d is_set=%d", p_scb->socket_id[1], FD_ISSET(p_scb->socket_id[1], p_org_set));
4698 p_mcb = BTIF_HL_GET_MCL_CB_PTR(p_scb->app_idx, p_scb->mcl_idx);
4699 p_dcb = BTIF_HL_GET_MDL_CB_PTR(p_scb->app_idx, p_scb->mcl_idx, p_scb->mdl_idx);
4700 p_acb = BTIF_HL_GET_APP_CB_PTR(p_scb->app_idx);
4703 btif_hl_stop_timer_using_handle(p_mcb->mcl_handle);
4704 evt_param.chan_cb.app_id = p_acb->app_id;
4705 memcpy(evt_param.chan_cb.bd_addr, p_mcb->bd_addr, sizeof(BD_ADDR));
4706 evt_param.chan_cb.channel_id = p_dcb->channel_id;
4707 evt_param.chan_cb.fd = p_scb->socket_id[0];
4708 evt_param.chan_cb.mdep_cfg_index = (int ) p_dcb->local_mdep_cfg_idx;
4709 evt_param.chan_cb.cb_state = BTIF_HL_CHAN_CB_STATE_CONNECTED_PENDING;
4710 len = sizeof(btif_hl_send_chan_state_cb_t);
4711 status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_SEND_CONNECTED_CB,
4712 (char*) &evt_param, len, NULL);
4713 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
4716 p_scb = (btif_hl_soc_cb_t *)GKI_getnext((void *)p_scb );
4717 BTIF_TRACE_DEBUG("next p_scb=0x%x", p_scb);
4721 BTIF_TRACE_DEBUG("leaving %s",__FUNCTION__);
4723 /*******************************************************************************
4725 ** Function btif_hl_close_socket
4727 ** Description close a socket
4731 *******************************************************************************/
4732 void btif_hl_close_socket( fd_set *p_org_set){
4733 btif_hl_soc_cb_t *p_scb = NULL;
4734 BOOLEAN element_removed = FALSE;
4735 btif_hl_mdl_cb_t *p_dcb = NULL ;
4736 btif_hl_app_cb_t *p_acb = NULL ;
4737 btif_hl_evt_cb_t evt_param;
4742 BTIF_TRACE_DEBUG("entering %s",__FUNCTION__);
4743 if (!GKI_queue_is_empty(&soc_queue))
4745 p_scb = (btif_hl_soc_cb_t *)GKI_getfirst((void *)&soc_queue);
4746 while (p_scb != NULL)
4748 if (btif_hl_get_socket_state(p_scb) == BTIF_HL_SOC_STATE_W4_REL)
4750 BTIF_TRACE_DEBUG("app_idx=%d mcl_id=%d, mdl_idx=%d",
4751 p_scb->app_idx, p_scb->mcl_idx, p_scb->mdl_idx);
4752 btif_hl_set_socket_state(p_scb, BTIF_HL_SOC_STATE_IDLE);
4753 if (p_scb->socket_id[1] != -1)
4755 FD_CLR(p_scb->socket_id[1] , p_org_set);
4756 shutdown(p_scb->socket_id[1], SHUT_RDWR);
4757 close(p_scb->socket_id[1]);
4759 evt_param.chan_cb.app_id = (int) btif_hl_get_app_id(p_scb->channel_id);
4760 memcpy(evt_param.chan_cb.bd_addr, p_scb->bd_addr, sizeof(BD_ADDR));
4761 evt_param.chan_cb.channel_id = p_scb->channel_id;
4762 evt_param.chan_cb.fd = p_scb->socket_id[0];
4763 evt_param.chan_cb.mdep_cfg_index = (int ) p_scb->mdep_cfg_idx;
4764 evt_param.chan_cb.cb_state = BTIF_HL_CHAN_CB_STATE_DISCONNECTED_PENDING;
4765 len = sizeof(btif_hl_send_chan_state_cb_t);
4766 status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_SEND_DISCONNECTED_CB,
4767 (char*) &evt_param, len, NULL);
4768 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
4773 p_scb = (btif_hl_soc_cb_t *)GKI_getnext((void *)p_scb );
4774 BTIF_TRACE_DEBUG("while loop next p_scb=0x%x", p_scb);
4777 p_scb = (btif_hl_soc_cb_t *)GKI_getfirst((void *)&soc_queue);
4778 while (p_scb != NULL)
4780 if (btif_hl_get_socket_state(p_scb) == BTIF_HL_SOC_STATE_IDLE)
4782 p_dcb = BTIF_HL_GET_MDL_CB_PTR(p_scb->app_idx, p_scb->mcl_idx, p_scb->mdl_idx);
4783 BTIF_TRACE_DEBUG("idle socket app_idx=%d mcl_id=%d, mdl_idx=%d p_dcb->in_use=%d",
4784 p_scb->app_idx, p_scb->mcl_idx, p_scb->mdl_idx, p_dcb->in_use);
4785 GKI_remove_from_queue((void *)&soc_queue, p_scb);
4786 btif_hl_free_buf((void **)&p_scb);
4787 p_dcb->p_scb = NULL;
4788 element_removed = TRUE;
4790 BTIF_TRACE_DEBUG("element_removed=%d p_scb=0x%x", element_removed, p_scb);
4791 if (element_removed)
4793 element_removed = FALSE;
4794 p_scb = (btif_hl_soc_cb_t *)GKI_getfirst((void *)&soc_queue);
4797 p_scb = (btif_hl_soc_cb_t *)GKI_getnext((void *)p_scb );
4799 BTIF_TRACE_DEBUG("while loop p_scb=0x%x", p_scb);
4802 BTIF_TRACE_DEBUG("leaving %s",__FUNCTION__);
4804 /*******************************************************************************
4806 ** Function btif_hl_select_wakeup_callback
4808 ** Description Select wakup callback to add or close a socket
4812 *******************************************************************************/
4814 void btif_hl_select_wakeup_callback( fd_set *p_org_set , int wakeup_signal){
4815 BTIF_TRACE_DEBUG("entering %s wakeup_signal=0x%04x",__FUNCTION__, wakeup_signal);
4817 if (wakeup_signal == btif_hl_signal_select_wakeup )
4819 btif_hl_add_socket_to_set(p_org_set);
4821 else if (wakeup_signal == btif_hl_signal_select_close_connected)
4823 btif_hl_close_socket(p_org_set);
4825 BTIF_TRACE_DEBUG("leaving %s",__FUNCTION__);
4828 /*******************************************************************************
4830 ** Function btif_hl_select_monitor_callback
4832 ** Description Select monitor callback to check pending socket actions
4836 *******************************************************************************/
4837 void btif_hl_select_monitor_callback( fd_set *p_cur_set , fd_set *p_org_set){
4838 btif_hl_soc_cb_t *p_scb = NULL;
4839 btif_hl_mdl_cb_t *p_dcb = NULL;
4843 BTIF_TRACE_DEBUG("entering %s",__FUNCTION__);
4845 if (!GKI_queue_is_empty(&soc_queue))
4847 p_scb = (btif_hl_soc_cb_t *)GKI_getfirst((void *)&soc_queue);
4848 BTIF_TRACE_DEBUG(" GKI queue is not empty ");
4849 while (p_scb != NULL)
4851 if (btif_hl_get_socket_state(p_scb) == BTIF_HL_SOC_STATE_W4_READ)
4853 if (FD_ISSET(p_scb->socket_id[1], p_cur_set))
4855 BTIF_TRACE_DEBUG("read data");
4856 BTIF_TRACE_DEBUG("state= BTIF_HL_SOC_STATE_W4_READ");
4857 p_dcb = BTIF_HL_GET_MDL_CB_PTR(p_scb->app_idx, p_scb->mcl_idx, p_scb->mdl_idx);
4858 if (p_dcb->p_tx_pkt)
4860 BTIF_TRACE_ERROR("Rcv new pkt but the last pkt is still not been sent tx_size=%d", p_dcb->tx_size);
4861 btif_hl_free_buf((void **) &p_dcb->p_tx_pkt);
4863 p_dcb->p_tx_pkt = btif_hl_get_buf (p_dcb->mtu);
4868 // r = recv(p_scb->socket_id[1], p_dcb->p_tx_pkt, p_dcb->mtu , MSG_DONTWAIT));
4869 // } while (r == SOCKET_ERROR && errno == EINTR);
4871 if ((r = (int)recv(p_scb->socket_id[1], p_dcb->p_tx_pkt, p_dcb->mtu , MSG_DONTWAIT)) > 0)
4873 BTIF_TRACE_DEBUG("btif_hl_select_monitor_callback send data r =%d", r);
4875 BTIF_TRACE_DEBUG("btif_hl_select_monitor_callback send data tx_size=%d", p_dcb->tx_size );
4876 BTA_HlSendData(p_dcb->mdl_handle, p_dcb->tx_size );
4881 BTIF_TRACE_DEBUG("btif_hl_select_monitor_callback receive failed r=%d",r);
4882 BTA_HlDchClose(p_dcb->mdl_handle );
4887 p_scb = (btif_hl_soc_cb_t *)GKI_getnext((void *)p_scb );
4892 BTIF_TRACE_DEBUG("btif_hl_select_monitor_queue is empty");
4894 BTIF_TRACE_DEBUG("leaving %s",__FUNCTION__);
4896 /*******************************************************************************
4898 ** Function btif_hl_select_wakeup_init
4900 ** Description select loop wakup init
4904 *******************************************************************************/
4905 static inline int btif_hl_select_wakeup_init(fd_set* set){
4906 BTIF_TRACE_DEBUG("%s", __func__);
4907 if (signal_fds[0] == -1 && socketpair(AF_UNIX, SOCK_STREAM, 0, signal_fds) < 0)
4909 BTIF_TRACE_ERROR("socketpair failed: %s", strerror(errno));
4913 BTIF_TRACE_DEBUG("btif_hl_select_wakeup_init signal_fds[0]=%d signal_fds[1]=%d",signal_fds[0], signal_fds[1] );
4914 FD_SET(signal_fds[0], set);
4916 return signal_fds[0];
4919 /*******************************************************************************
4921 ** Function btif_hl_select_wakeup
4923 ** Description send a signal to wakupo the select loop
4927 *******************************************************************************/
4928 static inline int btif_hl_select_wakeup(void){
4929 char sig_on = btif_hl_signal_select_wakeup;
4930 BTIF_TRACE_DEBUG("btif_hl_select_wakeup");
4931 return send(signal_fds[1], &sig_on, sizeof(sig_on), 0);
4934 /*******************************************************************************
4936 ** Function btif_hl_select_close_connected
4938 ** Description send a signal to close a socket
4942 *******************************************************************************/
4943 static inline int btif_hl_select_close_connected(void){
4944 char sig_on = btif_hl_signal_select_close_connected;
4945 BTIF_TRACE_DEBUG("btif_hl_select_close_connected");
4946 return send(signal_fds[1], &sig_on, sizeof(sig_on), 0);
4949 /*******************************************************************************
4951 ** Function btif_hl_close_select_thread
4953 ** Description send signal to close the thread and then close all signal FDs
4957 *******************************************************************************/
4958 static inline int btif_hl_close_select_thread(void)
4961 char sig_on = btif_hl_signal_select_exit;
4962 BTIF_TRACE_DEBUG("btif_hl_signal_select_exit");
4963 result = send(signal_fds[1], &sig_on, sizeof(sig_on), 0);
4964 if (btif_is_enabled())
4966 /* Wait for the select_thread_id to exit if BT is still enabled
4967 and only this profile getting cleaned up*/
4968 if (select_thread_id != -1) {
4969 pthread_join(select_thread_id, NULL);
4970 select_thread_id = -1;
4976 /*******************************************************************************
4978 ** Function btif_hl_select_wake_reset
4980 ** Description clear the received signal for the select loop
4984 *******************************************************************************/
4985 static inline int btif_hl_select_wake_reset(void){
4988 BTIF_TRACE_DEBUG("btif_hl_select_wake_reset");
4989 recv(signal_fds[0], &sig_recv, sizeof(sig_recv), MSG_WAITALL);
4990 return(int)sig_recv;
4992 /*******************************************************************************
4994 ** Function btif_hl_select_wake_signaled
4996 ** Description check whether a fd is set or not
5000 *******************************************************************************/
5001 static inline int btif_hl_select_wake_signaled(fd_set* set){
5002 BTIF_TRACE_DEBUG("btif_hl_select_wake_signaled");
5003 return FD_ISSET(signal_fds[0], set);
5005 /*******************************************************************************
5007 ** Function btif_hl_thread_cleanup
5009 ** Description shut down and clean up the select loop
5013 *******************************************************************************/
5014 static void btif_hl_thread_cleanup(){
5017 if (connected_s != -1)
5019 shutdown(connected_s, SHUT_RDWR);
5022 listen_s = connected_s = -1;
5023 BTIF_TRACE_DEBUG("hl thread cleanup");
5025 /*******************************************************************************
5027 ** Function btif_hl_select_thread
5029 ** Description the select loop
5033 *******************************************************************************/
5034 static void *btif_hl_select_thread(void *arg){
5035 fd_set org_set, curr_set;
5036 int r, max_curr_s, max_org_s;
5039 BTIF_TRACE_DEBUG("entered btif_hl_select_thread");
5041 max_org_s = btif_hl_select_wakeup_init(&org_set);
5042 BTIF_TRACE_DEBUG("max_s=%d ", max_org_s);
5047 BTIF_TRACE_DEBUG("set curr_set = org_set ");
5049 max_curr_s = max_org_s;
5050 int ret = select((max_curr_s + 1), &curr_set, NULL, NULL, NULL);
5051 BTIF_TRACE_DEBUG("select unblocked ret=%d", ret);
5054 BTIF_TRACE_DEBUG("select() ret -1, exit the thread");
5055 btif_hl_thread_cleanup();
5056 select_thread_id = -1;
5061 BTIF_TRACE_DEBUG("btif_hl_select_wake_signaled, signal ret=%d", ret);
5062 if (btif_hl_select_wake_signaled(&curr_set))
5064 r = btif_hl_select_wake_reset();
5065 BTIF_TRACE_DEBUG("btif_hl_select_wake_signaled, signal:%d", r);
5066 if (r == btif_hl_signal_select_wakeup || r == btif_hl_signal_select_close_connected )
5068 btif_hl_select_wakeup_callback(&org_set, r);
5070 else if( r == btif_hl_signal_select_exit)
5072 btif_hl_thread_cleanup();
5073 BTIF_TRACE_DEBUG("Exit hl_select_thread for btif_hl_signal_select_exit");
5078 btif_hl_select_monitor_callback(&curr_set, &org_set);
5079 max_org_s = btif_hl_update_maxfd(max_org_s);
5082 BTIF_TRACE_DEBUG("no data, select ret: %d\n", ret);
5084 BTIF_TRACE_DEBUG("leaving hl_select_thread");
5088 /*******************************************************************************
5090 ** Function create_thread
5092 ** Description creat a select loop
5094 ** Returns pthread_t
5096 *******************************************************************************/
5097 static inline pthread_t create_thread(void *(*start_routine)(void *), void * arg){
5098 BTIF_TRACE_DEBUG("create_thread: entered");
5099 pthread_attr_t thread_attr;
5101 pthread_attr_init(&thread_attr);
5102 pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_JOINABLE);
5103 pthread_t thread_id = -1;
5104 if ( pthread_create(&thread_id, &thread_attr, start_routine, arg)!=0 )
5106 BTIF_TRACE_ERROR("pthread_create : %s", strerror(errno));
5109 BTIF_TRACE_DEBUG("create_thread: thread created successfully");
5113 /*******************************************************************************
5115 ** Function btif_hl_soc_thread_init
5117 ** Description HL select loop init function.
5121 *******************************************************************************/
5122 void btif_hl_soc_thread_init(void){
5123 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
5124 GKI_init_q(&soc_queue);
5125 select_thread_id = create_thread(btif_hl_select_thread, NULL);
5127 /*******************************************************************************
5129 ** Function btif_hl_load_mdl_config
5131 ** Description load the MDL configuation from the application control block
5135 *******************************************************************************/
5136 BOOLEAN btif_hl_load_mdl_config (UINT8 app_id, UINT8 buffer_size,
5137 tBTA_HL_MDL_CFG *p_mdl_buf ){
5139 BOOLEAN result = FALSE;
5140 btif_hl_app_cb_t *p_acb;
5143 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
5145 if (btif_hl_find_app_idx(app_id, &app_idx))
5147 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
5148 for (i=0, p=p_mdl_buf; i<buffer_size; i++, p++)
5150 memcpy(p, &p_acb->mdl_cfg[i].base, sizeof(tBTA_HL_MDL_CFG));
5155 BTIF_TRACE_DEBUG("result=%d", result);