1 /******************************************************************************
2 *
3 * Copyright (C) 2009-2012 Broadcom Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 /************************************************************************************
20 *
21 * Filename: btif_hl.c
22 *
23 * Description: Health Device Profile Bluetooth Interface
24 *
25 *
26 ***********************************************************************************/
27 #define LOG_TAG "bt_btif_hl"
28
29 #include "btif_hl.h"
30
31 #include <assert.h>
32 #include <ctype.h>
33 #include <errno.h>
34 #include <fcntl.h>
35 #include <pthread.h>
36 #include <signal.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <sys/poll.h>
41 #include <sys/prctl.h>
42 #include <sys/select.h>
43 #include <sys/socket.h>
44 #include <sys/types.h>
45 #include <sys/un.h>
46 #include <time.h>
47 #include <unistd.h>
48
49 #include <hardware/bt_hl.h>
50
51 #include "bta_api.h"
52 #include "btif_common.h"
53 #include "btif_storage.h"
54 #include "btif_util.h"
55 #include "btu.h"
56 #include "mca_api.h"
57 #include "osi/include/list.h"
58 #include "osi/include/log.h"
59
60 #define MAX_DATATYPE_SUPPORTED 8
61
62 extern int btif_hl_update_maxfd( int max_org_s);
63 extern void btif_hl_select_monitor_callback( fd_set *p_cur_set, fd_set *p_org_set );
64 extern void btif_hl_select_wakeup_callback( fd_set *p_org_set , int wakeup_signal );
65 extern int btif_hl_update_maxfd( int max_org_s);
66 extern void btif_hl_select_monitor_callback( fd_set *p_cur_set, fd_set *p_org_set );
67 extern void btif_hl_select_wakeup_callback( fd_set *p_org_set , int wakeup_signal );
68 extern void btif_hl_soc_thread_init(void);
69 extern void btif_hl_release_mcl_sockets(UINT8 app_idx, UINT8 mcl_idx);
70 extern BOOLEAN btif_hl_create_socket(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx);
71 extern void btif_hl_release_socket(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx);
72
73 extern fixed_queue_t *btu_general_alarm_queue;
74
75 btif_hl_cb_t btif_hl_cb;
76 btif_hl_cb_t *p_btif_hl_cb = &btif_hl_cb;
77
78 /************************************************************************************
79 ** Static variables
80 ************************************************************************************/
81 static bthl_callbacks_t bt_hl_callbacks_cb;
82 static bthl_callbacks_t *bt_hl_callbacks=NULL;
83
84 /* signal socketpair to wake up select loop */
85
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;
89
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 list_t *soc_queue;
95 static int reg_counter;
96
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);
109
110 #define CHECK_CALL_CBACK(P_CB, P_CBACK, ...)\
111 if (P_CB && P_CB->P_CBACK) { \
112 P_CB->P_CBACK(__VA_ARGS__); \
113 } \
114 else { \
115 ASSERTC(0, "Callback is NULL", 0); \
116 }
117
118 #define BTIF_HL_CALL_CBACK(P_CB, P_CBACK, ...)\
119 if((p_btif_hl_cb->state != BTIF_HL_STATE_DISABLING) &&\
120 (p_btif_hl_cb->state != BTIF_HL_STATE_DISABLED)) \
121 { \
122 if (P_CB && P_CB->P_CBACK) { \
123 P_CB->P_CBACK(__VA_ARGS__); \
124 } \
125 else { \
126 ASSERTC(0, "Callback is NULL", 0); \
127 } \
128 }
129
130 #define CHECK_BTHL_INIT() if (bt_hl_callbacks == NULL)\
131 {\
132 BTIF_TRACE_WARNING("BTHL: %s: BTHL not initialized", __FUNCTION__);\
133 return BT_STATUS_NOT_READY;\
134 }\
135 else\
136 {\
137 BTIF_TRACE_EVENT("BTHL: %s", __FUNCTION__);\
138 }
139
140 static const btif_hl_data_type_cfg_t data_type_table[] = {
141 /* Data Specilization Ntx Nrx (from Bluetooth SIG's HDP whitepaper)*/
142 {BTIF_HL_DATA_TYPE_PULSE_OXIMETER, 9216, 256},
143 {BTIF_HL_DATA_TYPE_BLOOD_PRESSURE_MON, 896, 224},
144 {BTIF_HL_DATA_TYPE_BODY_THERMOMETER, 896, 224},
145 {BTIF_HL_DATA_TYPE_BODY_WEIGHT_SCALE, 896, 224},
146 {BTIF_HL_DATA_TYPE_GLUCOSE_METER, 896, 224},
147 {BTIF_HL_DATA_TYPE_STEP_COUNTER, 6624, 224},
148 {BTIF_HL_DATA_TYPE_BCA, 7730, 1230},
149 {BTIF_HL_DATA_TYPE_PEAK_FLOW , 2030, 224},
150 {BTIF_HL_DATA_TYPE_ACTIVITY_HUB, 5120, 224},
151 {BTIF_HL_DATA_TYPE_AMM, 1024, 64}
152 };
153
154 #define BTIF_HL_DATA_TABLE_SIZE (sizeof(data_type_table) / sizeof(btif_hl_data_type_cfg_t))
155 #define BTIF_HL_DEFAULT_SRC_TX_APDU_SIZE 10240 /* use this size if the data type is not
156 defined in the table; for future proof */
157 #define BTIF_HL_DEFAULT_SRC_RX_APDU_SIZE 512 /* use this size if the data type is not
158 defined in the table; for future proof */
159
160 #define BTIF_HL_ECHO_MAX_TX_RX_APDU_SIZE 1024
161
162 /************************************************************************************
163 ** Static utility functions
164 ************************************************************************************/
165
166 #define BTIF_IF_GET_NAME 16
btif_hl_display_calling_process_name(void)167 void btif_hl_display_calling_process_name(void)
168 {
169 char name[16];
170 prctl(BTIF_IF_GET_NAME, name, 0, 0, 0);
171 BTIF_TRACE_DEBUG("Process name (%s)", name);
172 }
173 #define BTIF_TIMEOUT_CCH_NO_DCH_MS (30 * 1000)
174
175 /*******************************************************************************
176 **
177 ** Function btif_hl_if_channel_setup_pending
178 **
179 ** Description check whether channel id is in setup pending state or not
180 **
181 ** Returns BOOLEAN
182 **
183 *******************************************************************************/
btif_hl_if_channel_setup_pending(int channel_id,UINT8 * p_app_idx,UINT8 * p_mcl_idx)184 BOOLEAN btif_hl_if_channel_setup_pending(int channel_id, UINT8 *p_app_idx, UINT8 *p_mcl_idx)
185 {
186 btif_hl_app_cb_t *p_acb;
187 btif_hl_mcl_cb_t *p_mcb;
188 UINT8 i, j;
189 BOOLEAN found=FALSE;
190
191 *p_app_idx = 0;
192 *p_mcl_idx = 0;
193 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
194 {
195 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
196 if (p_acb->in_use)
197 {
198 for (j=0; j< BTA_HL_NUM_MCLS; j++)
199 {
200 p_mcb = BTIF_HL_GET_MCL_CB_PTR(i, j);
201 if (p_mcb->in_use &&
202 p_mcb->is_connected && p_mcb->pcb.channel_id == channel_id )
203 {
204 found = TRUE;
205 *p_app_idx = i;
206 *p_mcl_idx = j;
207 break;
208 }
209 }
210 }
211 if (found)
212 break;
213 }
214 BTIF_TRACE_DEBUG("%s found=%d channel_id=0x%08x",
215 __FUNCTION__, found, channel_id, *p_app_idx, *p_mcl_idx);
216 return found;
217
218 }
219 /*******************************************************************************
220 **
221 ** Function btif_hl_num_dchs_in_use
222 **
223 ** Description find number of DCHs in use
224 **
225 ** Returns UINT8
226 *******************************************************************************/
btif_hl_num_dchs_in_use(UINT8 mcl_handle)227 UINT8 btif_hl_num_dchs_in_use(UINT8 mcl_handle){
228
229 btif_hl_app_cb_t * p_acb;
230 btif_hl_mcl_cb_t *p_mcb;
231 UINT8 i,j,x;
232 UINT8 cnt=0;
233
234 for (i=0; i<BTA_HL_NUM_APPS; i++)
235 {
236 BTIF_TRACE_DEBUG("btif_hl_num_dchs:i = %d",i);
237 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
238 if (p_acb && p_acb->in_use)
239 {
240 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
241 {
242 if(p_acb->mcb[j].in_use)
243 BTIF_TRACE_DEBUG("btif_hl_num_dchs:mcb in use j=%d, mcl_handle=%d,mcb handle=%d",
244 j,mcl_handle, p_acb->mcb[j].mcl_handle);
245 if (p_acb->mcb[j].in_use &&
246 (p_acb->mcb[j].mcl_handle == mcl_handle))
247 {
248 p_mcb = &p_acb->mcb[j];
249 BTIF_TRACE_DEBUG("btif_hl_num_dchs: mcl handle found j =%d",j);
250 for (x=0; x < BTA_HL_NUM_MDLS_PER_MCL ; x ++)
251 {
252 if (p_mcb->mdl[x].in_use)
253 {
254 BTIF_TRACE_DEBUG("btif_hl_num_dchs_in_use:found x =%d",x);
255 cnt++;
256 }
257 }
258 }
259 }
260 }
261 }
262
263 BTIF_TRACE_DEBUG("%s dch in use count=%d", __FUNCTION__, cnt);
264 return cnt;
265 }
266 /*******************************************************************************
267 **
268 ** Function btif_hl_timer_timeout
269 **
270 ** Description Process timer timeout
271 **
272 ** Returns void
273 *******************************************************************************/
btif_hl_timer_timeout(void * data)274 void btif_hl_timer_timeout(void *data)
275 {
276 btif_hl_mcl_cb_t *p_mcb = (btif_hl_mcl_cb_t *)data;
277
278 BTIF_TRACE_DEBUG("%s", __func__);
279 if (p_mcb->is_connected) {
280 BTIF_TRACE_DEBUG("Idle timeout Close CCH mcl_handle=%d",
281 p_mcb->mcl_handle);
282 BTA_HlCchClose(p_mcb->mcl_handle);
283 } else {
284 BTIF_TRACE_DEBUG("CCH idle timeout But CCH not connected");
285 }
286 }
287
288 /*******************************************************************************
289 **
290 ** Function btif_hl_stop_cch_timer
291 **
292 ** Description stop CCH timer
293 **
294 ** Returns void
295 *******************************************************************************/
btif_hl_stop_cch_timer(UINT8 app_idx,UINT8 mcl_idx)296 void btif_hl_stop_cch_timer(UINT8 app_idx, UINT8 mcl_idx)
297 {
298 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
299
300 BTIF_TRACE_DEBUG("%s app_idx=%d, mcl_idx=%d", __func__, app_idx, mcl_idx);
301 alarm_cancel(p_mcb->cch_timer);
302 }
303
304 /*******************************************************************************
305 **
306 ** Function btif_hl_start_cch_timer
307 **
308 ** Description start CCH timer
309 **
310 ** Returns void
311 *******************************************************************************/
btif_hl_start_cch_timer(UINT8 app_idx,UINT8 mcl_idx)312 void btif_hl_start_cch_timer(UINT8 app_idx, UINT8 mcl_idx)
313 {
314 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
315 BTIF_TRACE_DEBUG("%s app_idx=%d, mcl_idx=%d", __func__, app_idx, mcl_idx);
316
317 alarm_free(p_mcb->cch_timer);
318 p_mcb->cch_timer = alarm_new("btif_hl.mcl_cch_timer");
319 alarm_set_on_queue(p_mcb->cch_timer, BTIF_TIMEOUT_CCH_NO_DCH_MS,
320 btif_hl_timer_timeout, p_mcb,
321 btu_general_alarm_queue);
322 }
323
324 /*******************************************************************************
325 **
326 ** Function btif_hl_find_mdl_idx
327 **
328 ** Description Find the MDL index using MDL ID
329 **
330 ** Returns BOOLEAN
331 **
332 *******************************************************************************/
btif_hl_find_mdl_idx(UINT8 app_idx,UINT8 mcl_idx,UINT16 mdl_id,UINT8 * p_mdl_idx)333 static BOOLEAN btif_hl_find_mdl_idx(UINT8 app_idx, UINT8 mcl_idx, UINT16 mdl_id,
334 UINT8 *p_mdl_idx)
335 {
336 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
337 BOOLEAN found=FALSE;
338 UINT8 i;
339
340 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
341 {
342 if (p_mcb->mdl[i].in_use &&
343 (mdl_id !=0) &&
344 (p_mcb->mdl[i].mdl_id== mdl_id))
345 {
346 found = TRUE;
347 *p_mdl_idx = i;
348 break;
349 }
350 }
351
352 BTIF_TRACE_DEBUG("%s found=%d mdl_id=%d mdl_idx=%d ",
353 __FUNCTION__,found, mdl_id, i);
354
355 return found;
356 }
357
358 /*******************************************************************************
359 **
360 ** Function btif_hl_is_the_first_reliable_existed
361 **
362 ** Description This function checks whether the first reliable DCH channel
363 ** has been setup on the MCL or not
364 **
365 ** Returns BOOLEAN - TRUE exist
366 ** FALSE does not exist
367 **
368 *******************************************************************************/
btif_hl_is_the_first_reliable_existed(UINT8 app_idx,UINT8 mcl_idx)369 BOOLEAN btif_hl_is_the_first_reliable_existed(UINT8 app_idx, UINT8 mcl_idx )
370 {
371 btif_hl_mcl_cb_t *p_mcb =BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
372 BOOLEAN is_existed =FALSE;
373 UINT8 i ;
374
375 for (i=0; i< BTA_HL_NUM_MDLS_PER_MCL; i++)
376 {
377 if (p_mcb->mdl[i].in_use && p_mcb->mdl[i].is_the_first_reliable)
378 {
379 is_existed = TRUE;
380 break;
381 }
382 }
383
384 BTIF_TRACE_DEBUG("bta_hl_is_the_first_reliable_existed is_existed=%d ",is_existed );
385 return is_existed;
386 }
387 /*******************************************************************************
388 **
389 ** Function btif_hl_clean_delete_mdl
390 **
391 ** Description Cleanup the delete mdl control block
392 **
393 ** Returns Nothing
394 **
395 *******************************************************************************/
btif_hl_clean_delete_mdl(btif_hl_delete_mdl_t * p_cb)396 static void btif_hl_clean_delete_mdl(btif_hl_delete_mdl_t *p_cb)
397 {
398 BTIF_TRACE_DEBUG("%s", __FUNCTION__ );
399 memset(p_cb, 0 , sizeof(btif_hl_delete_mdl_t));
400 }
401
402 /*******************************************************************************
403 **
404 ** Function btif_hl_clean_pcb
405 **
406 ** Description Cleanup the pending chan control block
407 **
408 ** Returns Nothing
409 **
410 *******************************************************************************/
btif_hl_clean_pcb(btif_hl_pending_chan_cb_t * p_pcb)411 static void btif_hl_clean_pcb(btif_hl_pending_chan_cb_t *p_pcb)
412 {
413 BTIF_TRACE_DEBUG("%s", __FUNCTION__ );
414 memset(p_pcb, 0 , sizeof(btif_hl_pending_chan_cb_t));
415 }
416
417 /*******************************************************************************
418 **
419 ** Function btif_hl_clean_mdl_cb
420 **
421 ** Description Cleanup the MDL control block
422 **
423 ** Returns Nothing
424 **
425 *******************************************************************************/
btif_hl_clean_mdl_cb(btif_hl_mdl_cb_t * p_dcb)426 static void btif_hl_clean_mdl_cb(btif_hl_mdl_cb_t *p_dcb)
427 {
428 BTIF_TRACE_DEBUG("%s", __FUNCTION__ );
429 osi_free_and_reset((void **)&p_dcb->p_rx_pkt);
430 osi_free_and_reset((void **)&p_dcb->p_tx_pkt);
431 memset(p_dcb, 0 , sizeof(btif_hl_mdl_cb_t));
432 }
433
434 /*******************************************************************************
435 **
436 ** Function btif_hl_reset_mcb
437 **
438 ** Description Reset MCL control block
439 **
440 ** Returns BOOLEAN
441 **
442 *******************************************************************************/
btif_hl_clean_mcl_cb(UINT8 app_idx,UINT8 mcl_idx)443 static void btif_hl_clean_mcl_cb(UINT8 app_idx, UINT8 mcl_idx)
444 {
445 btif_hl_mcl_cb_t *p_mcb;
446 BTIF_TRACE_DEBUG("%s app_idx=%d, mcl_idx=%d", __FUNCTION__,app_idx, mcl_idx);
447 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
448 alarm_free(p_mcb->cch_timer);
449 memset(p_mcb, 0, sizeof(btif_hl_mcl_cb_t));
450 }
451
452 /*******************************************************************************
453 **
454 ** Function btif_hl_find_sdp_idx_using_mdep_filter
455 **
456 ** Description This function finds the SDP record index using MDEP filter parameters
457 **
458 ** Returns BOOLEAN
459 **
460 *******************************************************************************/
btif_hl_reset_mdep_filter(UINT8 app_idx)461 static void btif_hl_reset_mdep_filter(UINT8 app_idx)
462 {
463 btif_hl_app_cb_t *p_acb =BTIF_HL_GET_APP_CB_PTR(app_idx);
464 p_acb->filter.num_elems = 0;
465 }
466
467 /*******************************************************************************
468 **
469 ** Function btif_hl_find_sdp_idx_using_mdep_filter
470 **
471 ** Description This function finds the SDP record index using MDEP filter parameters
472 **
473 ** Returns BOOLEAN
474 **
475 *******************************************************************************/
btif_hl_find_sdp_idx_using_mdep_filter(UINT8 app_idx,UINT8 mcl_idx,UINT8 * p_sdp_idx)476 static BOOLEAN btif_hl_find_sdp_idx_using_mdep_filter(UINT8 app_idx, UINT8 mcl_idx, UINT8 *p_sdp_idx)
477 {
478 btif_hl_app_cb_t *p_acb =BTIF_HL_GET_APP_CB_PTR(app_idx);
479 btif_hl_mcl_cb_t *p_mcb =BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
480 UINT8 i, j, num_recs,num_elems, num_mdeps, mdep_idx;
481 tBTA_HL_MDEP_ROLE peer_mdep_role;
482 UINT16 data_type;
483 tBTA_HL_SDP_MDEP_CFG *p_mdep;
484 BOOLEAN found = FALSE;
485 BOOLEAN elem_found;
486
487 BTIF_TRACE_DEBUG("btif_hl_find_sdp_idx_using_mdep_filter");
488 num_recs = p_mcb->sdp.num_recs;
489 num_elems = p_acb->filter.num_elems;
490 if (!num_elems)
491 {
492 BTIF_TRACE_DEBUG("btif_hl_find_sdp_idx_using_mdep_filter num_elem=0");
493 *p_sdp_idx = 0;
494 found = TRUE;
495 return found;
496 }
497
498 for (i=0; i<num_recs; i++)
499 {
500 num_mdeps = p_mcb->sdp.sdp_rec[i].num_mdeps;
501 for (j=0; j<num_elems; j++ )
502 {
503 data_type = p_acb->filter.elem[j].data_type;
504 peer_mdep_role = p_acb->filter.elem[j].peer_mdep_role;
505 elem_found = FALSE;
506 mdep_idx=0;
507 while (!elem_found && mdep_idx < num_mdeps )
508 {
509 p_mdep = &(p_mcb->sdp.sdp_rec[i].mdep_cfg[mdep_idx]);
510 if ( (p_mdep->data_type == data_type) &&
511 (p_mdep->mdep_role == peer_mdep_role) )
512 {
513 elem_found = TRUE;
514 }
515 else
516 {
517 mdep_idx++;
518 }
519 }
520
521 if (!elem_found)
522 {
523 found = FALSE;
524 break;
525 }
526 else
527 {
528 found = TRUE;
529 }
530 }
531
532 if (found)
533 {
534 BTIF_TRACE_DEBUG("btif_hl_find_sdp_idx_using_mdep_filter found idx=%d",i);
535 *p_sdp_idx = i;
536 break;
537 }
538 }
539
540 BTIF_TRACE_DEBUG("%s found=%d sdp_idx=%d",__FUNCTION__ , found, *p_sdp_idx);
541
542 btif_hl_reset_mdep_filter(app_idx);
543
544 return found;
545 }
546 /*******************************************************************************
547 **
548 ** Function btif_hl_is_reconnect_possible
549 **
550 ** Description check reconnect is possible or not
551 **
552 ** Returns BOOLEAN
553 **
554 *******************************************************************************/
btif_hl_is_reconnect_possible(UINT8 app_idx,UINT8 mcl_idx,int mdep_cfg_idx,tBTA_HL_DCH_OPEN_PARAM * p_dch_open_api,tBTA_HL_MDL_ID * p_mdl_id)555 BOOLEAN btif_hl_is_reconnect_possible(UINT8 app_idx, UINT8 mcl_idx, int mdep_cfg_idx,
556 tBTA_HL_DCH_OPEN_PARAM *p_dch_open_api, tBTA_HL_MDL_ID *p_mdl_id)
557 {
558 btif_hl_app_cb_t *p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
559 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
560 tBTA_HL_DCH_CFG local_cfg = p_dch_open_api->local_cfg;
561 tBTA_HL_DCH_MODE dch_mode = BTA_HL_DCH_MODE_RELIABLE;
562 BOOLEAN use_mdl_dch_mode=FALSE;
563 btif_hl_mdl_cfg_t *p_mdl;
564 btif_hl_mdl_cfg_t *p_mdl1;
565 UINT8 i, j;
566 BOOLEAN is_reconnect_ok=FALSE;
567 BOOLEAN stream_mode_avail=FALSE;
568 UINT16 data_type = p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg.data_cfg[0].data_type;
569 tBTA_HL_MDEP_ID peer_mdep_id = p_dch_open_api->peer_mdep_id;
570 UINT8 mdl_idx;
571
572 BTIF_TRACE_DEBUG("%s app_idx=%d mcl_idx=%d mdep_cfg_idx=%d",
573 __FUNCTION__, app_idx, mcl_idx, mdep_cfg_idx );
574 switch (local_cfg)
575 {
576 case BTA_HL_DCH_CFG_NO_PREF:
577 if (!btif_hl_is_the_first_reliable_existed(app_idx, mcl_idx))
578 {
579 dch_mode = BTA_HL_DCH_MODE_RELIABLE;
580 }
581 else
582 {
583 use_mdl_dch_mode = TRUE;
584 }
585 break;
586 case BTA_HL_DCH_CFG_RELIABLE:
587 dch_mode = BTA_HL_DCH_MODE_RELIABLE;
588 break;
589 case BTA_HL_DCH_CFG_STREAMING:
590 dch_mode = BTA_HL_DCH_MODE_STREAMING;
591 break;
592 default:
593 BTIF_TRACE_ERROR("Invalid local_cfg=%d",local_cfg );
594 return is_reconnect_ok;
595 break;
596
597 }
598
599 BTIF_TRACE_DEBUG("local_cfg=%d use_mdl_dch_mode=%d dch_mode=%d ",
600 local_cfg, use_mdl_dch_mode, dch_mode );
601
602 for (i=0, p_mdl=&p_acb->mdl_cfg[0] ; i< BTA_HL_NUM_MDL_CFGS; i++, p_mdl++ )
603 {
604 if (p_mdl->base.active &&
605 p_mdl->extra.data_type ==data_type &&
606 (p_mdl->extra.peer_mdep_id != BTA_HL_INVALID_MDEP_ID && p_mdl->extra.peer_mdep_id == peer_mdep_id) &&
607 memcpy(p_mdl->base.peer_bd_addr, p_mcb->bd_addr,sizeof(BD_ADDR) ) &&
608 p_mdl->base.mdl_id &&
609 !btif_hl_find_mdl_idx(app_idx, mcl_idx,p_mdl->base.mdl_id, &mdl_idx))
610 {
611 BTIF_TRACE_DEBUG("i=%d Matched active=%d mdl_id =%d, mdl_dch_mode=%d",
612 i, p_mdl->base.active, p_mdl->base.mdl_id,p_mdl->base.dch_mode);
613 if (!use_mdl_dch_mode)
614 {
615 if (p_mdl->base.dch_mode == dch_mode)
616 {
617 is_reconnect_ok = TRUE;
618 *p_mdl_id = p_mdl->base.mdl_id;
619 BTIF_TRACE_DEBUG("reconnect is possible dch_mode=%d mdl_id=%d", dch_mode, p_mdl->base.mdl_id );
620 break;
621 }
622 }
623 else
624 {
625 is_reconnect_ok = TRUE;
626 for (j=i, p_mdl1=&p_acb->mdl_cfg[i]; j< BTA_HL_NUM_MDL_CFGS; j++, p_mdl1++)
627 {
628 if (p_mdl1->base.active &&
629 p_mdl1->extra.data_type == data_type &&
630 (p_mdl1->extra.peer_mdep_id != BTA_HL_INVALID_MDEP_ID && p_mdl1->extra.peer_mdep_id == peer_mdep_id) &&
631 memcpy(p_mdl1->base.peer_bd_addr, p_mcb->bd_addr,sizeof(BD_ADDR)) &&
632 p_mdl1->base.dch_mode == BTA_HL_DCH_MODE_STREAMING)
633 {
634 stream_mode_avail = TRUE;
635 BTIF_TRACE_DEBUG("found streaming mode mdl index=%d", j);
636 break;
637 }
638 }
639
640 if (stream_mode_avail)
641 {
642 dch_mode = BTA_HL_DCH_MODE_STREAMING;
643 *p_mdl_id = p_mdl1->base.mdl_id;
644 BTIF_TRACE_DEBUG("reconnect is ok index=%d dch_mode=streaming mdl_id=%d", j, *p_mdl_id);
645 break;
646 }
647 else
648 {
649 dch_mode= p_mdl->base.dch_mode;
650 *p_mdl_id = p_mdl->base.mdl_id;
651 BTIF_TRACE_DEBUG("reconnect is ok index=%d dch_mode=%d mdl_id=%d", i, p_mdl->base.dch_mode, *p_mdl_id);
652 break;
653
654 }
655 }
656
657 }
658
659 }
660
661 BTIF_TRACE_DEBUG("is_reconnect_ok dch_mode=%d mdl_id=%d",is_reconnect_ok, dch_mode, *p_mdl_id);
662 return is_reconnect_ok;
663 }
664
665 /*******************************************************************************
666 **
667 ** Function btif_hl_dch_open
668 **
669 ** Description Process DCH open request using the DCH Open API parameters
670 **
671 ** Returns BOOLEAN
672 **
673 *******************************************************************************/
btif_hl_dch_open(UINT8 app_id,BD_ADDR bd_addr,tBTA_HL_DCH_OPEN_PARAM * p_dch_open_api,int mdep_cfg_idx,btif_hl_pend_dch_op_t op,int * channel_id)674 BOOLEAN btif_hl_dch_open(UINT8 app_id, BD_ADDR bd_addr,
675 tBTA_HL_DCH_OPEN_PARAM *p_dch_open_api,
676 int mdep_cfg_idx,
677 btif_hl_pend_dch_op_t op, int *channel_id){
678 btif_hl_app_cb_t *p_acb;
679 btif_hl_mcl_cb_t *p_mcb;
680 btif_hl_pending_chan_cb_t *p_pcb;
681 UINT8 app_idx, mcl_idx;
682 BOOLEAN status = FALSE;
683 tBTA_HL_MDL_ID mdl_id;
684 tBTA_HL_DCH_RECONNECT_PARAM reconnect_param;
685
686 BTIF_TRACE_DEBUG("%s app_id=%d ",
687 __FUNCTION__, app_id );
688 BTIF_TRACE_DEBUG("DB [%02x:%02x:%02x:%02x:%02x:%02x]",
689 bd_addr[0], bd_addr[1],bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5]);
690
691 if (btif_hl_find_app_idx(app_id, &app_idx))
692 {
693 if (btif_hl_find_mcl_idx(app_idx, bd_addr , &mcl_idx))
694 {
695 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
696
697 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
698 if (!p_pcb->in_use)
699 {
700 p_mcb->req_ctrl_psm = p_dch_open_api->ctrl_psm;
701
702 p_pcb->in_use = TRUE;
703 *channel_id =
704 p_pcb->channel_id = (int) btif_hl_get_next_channel_id(app_id);
705 p_pcb->cb_state = BTIF_HL_CHAN_CB_STATE_CONNECTING_PENDING;
706 p_pcb->mdep_cfg_idx = mdep_cfg_idx;
707 memcpy(p_pcb->bd_addr, bd_addr, sizeof(BD_ADDR));
708 p_pcb->op = op;
709
710 if (p_mcb->sdp.num_recs)
711 {
712 if (p_mcb->valid_sdp_idx)
713 {
714 p_dch_open_api->ctrl_psm = p_mcb->ctrl_psm;
715 }
716
717 if (!btif_hl_is_reconnect_possible(app_idx, mcl_idx, mdep_cfg_idx, p_dch_open_api, &mdl_id ))
718 {
719
720 BTIF_TRACE_DEBUG("Issue DCH open" );
721 BTA_HlDchOpen(p_mcb->mcl_handle, p_dch_open_api);
722 }
723 else
724 {
725 reconnect_param.ctrl_psm = p_mcb->ctrl_psm;
726 reconnect_param.mdl_id = mdl_id;;
727 BTIF_TRACE_DEBUG("Issue Reconnect ctrl_psm=0x%x mdl_id=0x%x",reconnect_param.ctrl_psm, reconnect_param.mdl_id );
728 BTA_HlDchReconnect(p_mcb->mcl_handle, &reconnect_param);
729 }
730
731 status = TRUE;
732 }
733 else
734 {
735 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
736 p_mcb->cch_oper = BTIF_HL_CCH_OP_DCH_OPEN;
737 BTA_HlSdpQuery(app_id,p_acb->app_handle, bd_addr);
738 status = TRUE;
739 }
740 }
741 }
742 }
743
744 BTIF_TRACE_DEBUG("status=%d ", status);
745 return status;
746 }
747 /*******************************************************************************
748 **
749 ** Function btif_hl_copy_bda
750 **
751 ** Description copy bt_bdaddr_t to BD_ADDR format
752 **
753 ** Returns void
754 **
755 *******************************************************************************/
btif_hl_copy_bda(bt_bdaddr_t * bd_addr,BD_ADDR bda)756 void btif_hl_copy_bda(bt_bdaddr_t *bd_addr, BD_ADDR bda){
757 UINT8 i;
758 for (i=0; i<6; i++)
759 {
760 bd_addr->address[i] = bda[i] ;
761 }
762 }
763 /*******************************************************************************
764 **
765 ** Function btif_hl_copy_bda
766 **
767 ** Description display bt_bdaddr_t
768 **
769 ** Returns BOOLEAN
770 **
771 *******************************************************************************/
btif_hl_display_bt_bda(bt_bdaddr_t * bd_addr)772 void btif_hl_display_bt_bda(bt_bdaddr_t *bd_addr){
773 BTIF_TRACE_DEBUG("DB [%02x:%02x:%02x:%02x:%02x:%02x]",
774 bd_addr->address[0], bd_addr->address[1], bd_addr->address[2],
775 bd_addr->address[3], bd_addr->address[4], bd_addr->address[5]);
776 }
777
778 /*******************************************************************************
779 **
780 ** Function btif_hl_dch_abort
781 **
782 ** Description Process DCH abort request
783 **
784 ** Returns Nothing
785 **
786 *******************************************************************************/
btif_hl_dch_abort(UINT8 app_idx,UINT8 mcl_idx)787 void btif_hl_dch_abort(UINT8 app_idx, UINT8 mcl_idx){
788 btif_hl_mcl_cb_t *p_mcb;
789
790 BTIF_TRACE_DEBUG("%s app_idx=%d mcl_idx=%d",__FUNCTION__, app_idx, mcl_idx );
791 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
792 if (p_mcb->is_connected)
793 {
794 BTA_HlDchAbort(p_mcb->mcl_handle);
795 }
796 else
797 {
798 p_mcb->pcb.abort_pending = TRUE;
799 }
800
801 }
802 /*******************************************************************************
803 **
804 ** Function btif_hl_cch_open
805 **
806 ** Description Process CCH open request
807 **
808 ** Returns Nothing
809 **
810 *******************************************************************************/
btif_hl_cch_open(UINT8 app_id,BD_ADDR bd_addr,UINT16 ctrl_psm,int mdep_cfg_idx,btif_hl_pend_dch_op_t op,int * channel_id)811 BOOLEAN btif_hl_cch_open(UINT8 app_id, BD_ADDR bd_addr, UINT16 ctrl_psm,
812 int mdep_cfg_idx,
813 btif_hl_pend_dch_op_t op, int *channel_id){
814
815 btif_hl_app_cb_t *p_acb;
816 btif_hl_mcl_cb_t *p_mcb;
817 btif_hl_pending_chan_cb_t *p_pcb;
818 UINT8 app_idx, mcl_idx;
819 BOOLEAN status = TRUE;
820
821 BTIF_TRACE_DEBUG("%s app_id=%d ctrl_psm=%d mdep_cfg_idx=%d op=%d",
822 __FUNCTION__, app_id, ctrl_psm, mdep_cfg_idx, op);
823 BTIF_TRACE_DEBUG("DB [%02x:%02x:%02x:%02x:%02x:%02x]",
824 bd_addr[0], bd_addr[1],bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5]);
825
826 if (btif_hl_find_app_idx(app_id, &app_idx))
827 {
828 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
829
830 if (!btif_hl_find_mcl_idx(app_idx, bd_addr, &mcl_idx))
831 {
832 if (btif_hl_find_avail_mcl_idx(app_idx, &mcl_idx))
833 {
834 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
835 alarm_free(p_mcb->cch_timer);
836 memset(p_mcb, 0, sizeof(btif_hl_mcl_cb_t));
837 p_mcb->in_use = TRUE;
838 bdcpy(p_mcb->bd_addr, bd_addr);
839
840 if (!ctrl_psm)
841 {
842 p_mcb->cch_oper = BTIF_HL_CCH_OP_MDEP_FILTERING;
843 }
844 else
845 {
846 p_mcb->cch_oper = BTIF_HL_CCH_OP_MATCHED_CTRL_PSM;
847 p_mcb->req_ctrl_psm = ctrl_psm;
848 }
849
850 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
851 p_pcb->in_use = TRUE;
852 p_pcb->mdep_cfg_idx = mdep_cfg_idx;
853 memcpy(p_pcb->bd_addr, bd_addr, sizeof(BD_ADDR));
854 p_pcb->op = op;
855
856 switch (op)
857 {
858 case BTIF_HL_PEND_DCH_OP_OPEN:
859 *channel_id =
860 p_pcb->channel_id = (int) btif_hl_get_next_channel_id(app_id);
861 p_pcb->cb_state = BTIF_HL_CHAN_CB_STATE_CONNECTING_PENDING;
862 break;
863 case BTIF_HL_PEND_DCH_OP_DELETE_MDL:
864 p_pcb->channel_id = p_acb->delete_mdl.channel_id;
865 p_pcb->cb_state = BTIF_HL_CHAN_CB_STATE_DESTROYED_PENDING;
866 break;
867 default:
868 break;
869 }
870 BTA_HlSdpQuery(app_id,p_acb->app_handle, bd_addr);
871 }
872 else
873 {
874 status = FALSE;
875 BTIF_TRACE_ERROR("Open CCH request discarded- No mcl cb");
876 }
877 }
878 else
879 {
880 status = FALSE;
881 BTIF_TRACE_ERROR("Open CCH request discarded- already in USE");
882 }
883 }
884 else
885 {
886 status = FALSE;
887 BTIF_TRACE_ERROR("Invalid app_id=%d", app_id);
888 }
889
890 if (channel_id)
891 {
892 BTIF_TRACE_DEBUG("status=%d channel_id=0x%08x", status, *channel_id);
893 }
894 else
895 {
896 BTIF_TRACE_DEBUG("status=%d ", status);
897 }
898 return status;
899 }
900
901 /*******************************************************************************
902 **
903 ** Function btif_hl_find_mdl_idx_using_handle
904 **
905 ** Description Find the MDL index using channel id
906 **
907 ** Returns BOOLEAN
908 **
909 *******************************************************************************/
btif_hl_find_mdl_cfg_idx_using_channel_id(int channel_id,UINT8 * p_app_idx,UINT8 * p_mdl_cfg_idx)910 BOOLEAN btif_hl_find_mdl_cfg_idx_using_channel_id(int channel_id,
911 UINT8 *p_app_idx,
912 UINT8 *p_mdl_cfg_idx){
913 btif_hl_app_cb_t *p_acb;
914 btif_hl_mdl_cfg_t *p_mdl;
915 BOOLEAN found=FALSE;
916 UINT8 i,j;
917 int mdl_cfg_channel_id;
918
919 *p_app_idx = 0;
920 *p_mdl_cfg_idx =0;
921 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
922 {
923 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
924 for (j=0; j< BTA_HL_NUM_MDL_CFGS; j++)
925 {
926 p_mdl =BTIF_HL_GET_MDL_CFG_PTR(i,j);
927 mdl_cfg_channel_id = *(BTIF_HL_GET_MDL_CFG_CHANNEL_ID_PTR(i,j));
928 if (p_acb->in_use &&
929 p_mdl->base.active &&
930 (mdl_cfg_channel_id == channel_id))
931 {
932 found = TRUE;
933 *p_app_idx = i;
934 *p_mdl_cfg_idx =j;
935 break;
936 }
937 }
938 }
939
940 BTIF_TRACE_EVENT("%s found=%d channel_id=0x%08x, app_idx=%d mdl_cfg_idx=%d ",
941 __FUNCTION__,found,channel_id, i,j );
942 return found;
943 }
944 /*******************************************************************************
945 **
946 ** Function btif_hl_find_mdl_idx_using_handle
947 **
948 ** Description Find the MDL index using channel id
949 **
950 ** Returns BOOLEAN
951 **
952 *******************************************************************************/
btif_hl_find_mdl_idx_using_channel_id(int channel_id,UINT8 * p_app_idx,UINT8 * p_mcl_idx,UINT8 * p_mdl_idx)953 BOOLEAN btif_hl_find_mdl_idx_using_channel_id(int channel_id,
954 UINT8 *p_app_idx,UINT8 *p_mcl_idx,
955 UINT8 *p_mdl_idx){
956 btif_hl_app_cb_t *p_acb;
957 btif_hl_mcl_cb_t *p_mcb;
958 btif_hl_mdl_cb_t *p_dcb;
959 BOOLEAN found=FALSE;
960 UINT8 i,j,k;
961
962 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
963 {
964 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
965 for (j=0; j< BTA_HL_NUM_MCLS; j++)
966 {
967 p_mcb =BTIF_HL_GET_MCL_CB_PTR(i,j);
968 for (k=0; k< BTA_HL_NUM_MDLS_PER_MCL; k++)
969 {
970 p_dcb =BTIF_HL_GET_MDL_CB_PTR(i,j,k);
971 if (p_acb->in_use &&
972 p_mcb->in_use &&
973 p_dcb->in_use &&
974 (p_dcb->channel_id == channel_id))
975 {
976 found = TRUE;
977 *p_app_idx = i;
978 *p_mcl_idx =j;
979 *p_mdl_idx = k;
980 break;
981 }
982 }
983 }
984 }
985 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d mcl_idx=%d mdl_idx=%d ",
986 __FUNCTION__,found,i,j,k );
987 return found;
988 }
989
990 /*******************************************************************************
991 **
992 ** Function btif_hl_find_channel_id_using_mdl_id
993 **
994 ** Description Find channel id using mdl_id'
995 **
996 ** Returns BOOLEAN
997 *********************************************************************************/
btif_hl_find_channel_id_using_mdl_id(UINT8 app_idx,tBTA_HL_MDL_ID mdl_id,int * p_channel_id)998 BOOLEAN btif_hl_find_channel_id_using_mdl_id(UINT8 app_idx, tBTA_HL_MDL_ID mdl_id,
999 int *p_channel_id){
1000 btif_hl_app_cb_t *p_acb;
1001 btif_hl_mdl_cfg_t *p_mdl;
1002 BOOLEAN found=FALSE;
1003 UINT8 j=0;
1004 int mdl_cfg_channel_id;
1005 p_acb =BTIF_HL_GET_APP_CB_PTR(app_idx);
1006 if (p_acb && p_acb->in_use)
1007 {
1008 for (j=0; j< BTA_HL_NUM_MDL_CFGS; j++)
1009 {
1010 p_mdl =BTIF_HL_GET_MDL_CFG_PTR(app_idx,j);
1011 mdl_cfg_channel_id = *(BTIF_HL_GET_MDL_CFG_CHANNEL_ID_PTR(app_idx,j));
1012 if ( p_mdl->base.active && (p_mdl->base.mdl_id == mdl_id))
1013 {
1014 found = TRUE;
1015 *p_channel_id = mdl_cfg_channel_id;
1016 break;
1017 }
1018 }
1019 }
1020 BTIF_TRACE_EVENT("%s found=%d channel_id=0x%08x, mdl_id=0x%x app_idx=%d mdl_cfg_idx=%d ",
1021 __FUNCTION__,found,*p_channel_id,mdl_id, app_idx,j );
1022 return found;
1023 }
1024
1025 /*******************************************************************************
1026 **
1027 ** Function btif_hl_find_mdl_idx_using_handle
1028 **
1029 ** Description Find the MDL index using handle
1030 **
1031 ** Returns BOOLEAN
1032 **
1033 *******************************************************************************/
btif_hl_find_mdl_idx_using_handle(tBTA_HL_MDL_HANDLE mdl_handle,UINT8 * p_app_idx,UINT8 * p_mcl_idx,UINT8 * p_mdl_idx)1034 BOOLEAN btif_hl_find_mdl_idx_using_handle(tBTA_HL_MDL_HANDLE mdl_handle,
1035 UINT8 *p_app_idx,UINT8 *p_mcl_idx,
1036 UINT8 *p_mdl_idx){
1037 btif_hl_app_cb_t *p_acb;
1038 btif_hl_mcl_cb_t *p_mcb;
1039 btif_hl_mdl_cb_t *p_dcb;
1040 BOOLEAN found=FALSE;
1041 UINT8 i,j,k;
1042
1043 *p_app_idx = 0;
1044 *p_mcl_idx =0;
1045 *p_mdl_idx = 0;
1046 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1047 {
1048 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
1049 for (j=0; j< BTA_HL_NUM_MCLS; j++)
1050 {
1051 p_mcb =BTIF_HL_GET_MCL_CB_PTR(i,j);
1052 for (k=0; k< BTA_HL_NUM_MDLS_PER_MCL; k++)
1053 {
1054 p_dcb =BTIF_HL_GET_MDL_CB_PTR(i,j,k);
1055 if (p_acb->in_use &&
1056 p_mcb->in_use &&
1057 p_dcb->in_use &&
1058 (p_dcb->mdl_handle == mdl_handle))
1059 {
1060 found = TRUE;
1061 *p_app_idx = i;
1062 *p_mcl_idx =j;
1063 *p_mdl_idx = k;
1064 break;
1065 }
1066 }
1067 }
1068 }
1069
1070 BTIF_TRACE_EVENT("%s found=%d app_idx=%d mcl_idx=%d mdl_idx=%d ",
1071 __FUNCTION__,found,i,j,k );
1072 return found;
1073 }
1074 /*******************************************************************************
1075 **
1076 ** Function btif_hl_find_peer_mdep_id
1077 **
1078 ** Description Find the peer MDEP ID from the received SPD records
1079 **
1080 ** Returns BOOLEAN
1081 **
1082 *******************************************************************************/
btif_hl_find_peer_mdep_id(UINT8 app_id,BD_ADDR bd_addr,tBTA_HL_MDEP_ROLE local_mdep_role,UINT16 data_type,tBTA_HL_MDEP_ID * p_peer_mdep_id)1083 static BOOLEAN btif_hl_find_peer_mdep_id(UINT8 app_id, BD_ADDR bd_addr,
1084 tBTA_HL_MDEP_ROLE local_mdep_role,
1085 UINT16 data_type,
1086 tBTA_HL_MDEP_ID *p_peer_mdep_id){
1087 UINT8 app_idx, mcl_idx;
1088 btif_hl_mcl_cb_t *p_mcb;
1089 tBTA_HL_SDP_REC *p_rec;
1090 UINT8 i, num_mdeps;
1091 BOOLEAN found = FALSE;
1092 tBTA_HL_MDEP_ROLE peer_mdep_role;
1093
1094 BTIF_TRACE_DEBUG("%s app_id=%d local_mdep_role=%d, data_type=%d",
1095 __FUNCTION__, app_id, local_mdep_role, data_type);
1096
1097 BTIF_TRACE_DEBUG("DB [%02x:%02x:%02x:%02x:%02x:%02x]",
1098 bd_addr[0], bd_addr[1],
1099 bd_addr[2], bd_addr[3],
1100 bd_addr[4], bd_addr[5]);
1101
1102 BTIF_TRACE_DEBUG("local_mdep_role=%d", local_mdep_role);
1103 BTIF_TRACE_DEBUG("data_type=%d", data_type);
1104
1105 if (local_mdep_role == BTA_HL_MDEP_ROLE_SINK)
1106 peer_mdep_role = BTA_HL_MDEP_ROLE_SOURCE;
1107 else
1108 peer_mdep_role = BTA_HL_MDEP_ROLE_SINK;
1109
1110 if (btif_hl_find_app_idx(app_id, &app_idx) )
1111 {
1112 if (btif_hl_find_mcl_idx(app_idx, bd_addr, &mcl_idx))
1113 {
1114 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1115
1116 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d",app_idx, mcl_idx);
1117 BTIF_TRACE_DEBUG("valid_spd_idx=%d sdp_idx=%d",p_mcb->valid_sdp_idx, p_mcb->sdp_idx);
1118 if (p_mcb->valid_sdp_idx)
1119 {
1120 p_rec = &p_mcb->sdp.sdp_rec[p_mcb->sdp_idx];
1121 num_mdeps = p_rec->num_mdeps;
1122 BTIF_TRACE_DEBUG("num_mdeps=%d", num_mdeps);
1123
1124 for (i = 0; i < num_mdeps; i++)
1125 {
1126 BTIF_TRACE_DEBUG("p_rec->mdep_cfg[%d].mdep_role=%d",i, p_rec->mdep_cfg[i].mdep_role);
1127 BTIF_TRACE_DEBUG("p_rec->mdep_cfg[%d].data_type =%d",i, p_rec->mdep_cfg[i].data_type );
1128 if ((p_rec->mdep_cfg[i].mdep_role == peer_mdep_role) &&
1129 (p_rec->mdep_cfg[i].data_type == data_type))
1130 {
1131 found = TRUE;
1132 *p_peer_mdep_id = p_rec->mdep_cfg[i].mdep_id;
1133 break;
1134 }
1135 }
1136 }
1137 }
1138 }
1139
1140 BTIF_TRACE_DEBUG("found =%d *p_peer_mdep_id=%d", found, *p_peer_mdep_id);
1141
1142 return found;
1143 }
1144
1145 /*******************************************************************************
1146 **
1147 ** Function btif_hl_find_mdep_cfg_idx
1148 **
1149 ** Description Find the MDEP configuration index using local MDEP_ID
1150 **
1151 ** Returns BOOLEAN
1152 **
1153 *******************************************************************************/
btif_hl_find_mdep_cfg_idx(UINT8 app_idx,tBTA_HL_MDEP_ID local_mdep_id,UINT8 * p_mdep_cfg_idx)1154 static BOOLEAN btif_hl_find_mdep_cfg_idx(UINT8 app_idx, tBTA_HL_MDEP_ID local_mdep_id,
1155 UINT8 *p_mdep_cfg_idx){
1156 btif_hl_app_cb_t *p_acb =BTIF_HL_GET_APP_CB_PTR(app_idx);
1157 tBTA_HL_SUP_FEATURE *p_sup_feature= &p_acb->sup_feature;
1158 BOOLEAN found =FALSE;
1159 UINT8 i;
1160
1161 for (i=0; i< p_sup_feature->num_of_mdeps; i++)
1162 {
1163 BTIF_TRACE_DEBUG("btif_hl_find_mdep_cfg_idx: mdep_id=%d app_idx = %d",
1164 p_sup_feature->mdep[i].mdep_id,app_idx);
1165 if ( p_sup_feature->mdep[i].mdep_id == local_mdep_id)
1166 {
1167 found = TRUE;
1168 *p_mdep_cfg_idx = i;
1169 break;
1170 }
1171 }
1172
1173 BTIF_TRACE_DEBUG("%s found=%d mdep_idx=%d local_mdep_id=%d app_idx=%d ",
1174 __FUNCTION__, found,i, local_mdep_id,app_idx);
1175 return found;
1176 }
1177
1178 /*******************************************************************************
1179 **
1180 ** Function btif_hl_find_mcl_idx
1181 **
1182 ** Description Find the MCL index using BD address
1183 **
1184 ** Returns BOOLEAN
1185 **
1186 *******************************************************************************/
btif_hl_find_mcl_idx(UINT8 app_idx,BD_ADDR p_bd_addr,UINT8 * p_mcl_idx)1187 BOOLEAN btif_hl_find_mcl_idx(UINT8 app_idx, BD_ADDR p_bd_addr, UINT8 *p_mcl_idx){
1188 BOOLEAN found=FALSE;
1189 UINT8 i;
1190 btif_hl_mcl_cb_t *p_mcb;
1191
1192 *p_mcl_idx = 0;
1193 for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
1194 {
1195 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, i);
1196 if (p_mcb->in_use &&
1197 (!memcmp (p_mcb->bd_addr, p_bd_addr, BD_ADDR_LEN)))
1198 {
1199 found = TRUE;
1200 *p_mcl_idx = i;
1201 break;
1202 }
1203 }
1204
1205 BTIF_TRACE_DEBUG("%s found=%d idx=%d",__FUNCTION__, found, i);
1206 return found;
1207 }
1208 /*******************************************************************************
1209 **
1210 ** Function btif_hl_init
1211 **
1212 ** Description HL initialization function.
1213 **
1214 ** Returns void
1215 **
1216 *******************************************************************************/
btif_hl_init(void)1217 static void btif_hl_init(void){
1218 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
1219 memset(p_btif_hl_cb, 0, sizeof(btif_hl_cb_t));
1220 btif_hl_init_next_app_id();
1221 btif_hl_init_next_channel_id();
1222 }
1223 /*******************************************************************************
1224 **
1225 ** Function btif_hl_disable
1226 **
1227 ** Description Disable initialization function.
1228 **
1229 ** Returns void
1230 **
1231 *******************************************************************************/
btif_hl_disable(void)1232 static void btif_hl_disable(void){
1233 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
1234
1235 if ((p_btif_hl_cb->state != BTIF_HL_STATE_DISABLING) &&
1236 (p_btif_hl_cb->state != BTIF_HL_STATE_DISABLED))
1237 {
1238 btif_hl_set_state(BTIF_HL_STATE_DISABLING);
1239 BTA_HlDisable();
1240 }
1241 }
1242 /*******************************************************************************
1243 **
1244 ** Function btif_hl_is_no_active_app
1245 **
1246 ** Description Find whether or not any APP is still in use
1247 **
1248 ** Returns BOOLEAN
1249 **
1250 *******************************************************************************/
btif_hl_is_no_active_app(void)1251 static BOOLEAN btif_hl_is_no_active_app(void){
1252 BOOLEAN no_active_app = TRUE;
1253 UINT8 i;
1254
1255 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1256 {
1257 if (btif_hl_cb.acb[i].in_use)
1258 {
1259 no_active_app = FALSE;
1260 break;
1261 }
1262 }
1263
1264 BTIF_TRACE_DEBUG("%s no_active_app=%d ", __FUNCTION__, no_active_app );
1265 return no_active_app;
1266 }
1267
1268 /*******************************************************************************
1269 **
1270 ** Function btif_hl_free_app_idx
1271 **
1272 ** Description free an application control block
1273 **
1274 ** Returns void
1275 **
1276 *******************************************************************************/
btif_hl_free_app_idx(UINT8 app_idx)1277 static void btif_hl_free_app_idx(UINT8 app_idx){
1278
1279 if ((app_idx < BTA_HL_NUM_APPS) && btif_hl_cb.acb[app_idx].in_use )
1280 {
1281 btif_hl_cb.acb[app_idx].in_use = FALSE;
1282 for (size_t i = 0; i < BTA_HL_NUM_MCLS; i++)
1283 alarm_free(btif_hl_cb.acb[app_idx].mcb[i].cch_timer);
1284 memset(&btif_hl_cb.acb[app_idx], 0, sizeof(btif_hl_app_cb_t));
1285 }
1286 }
1287 /*******************************************************************************
1288 **
1289 ** Function btif_hl_set_state
1290 **
1291 ** Description set HL state
1292 **
1293 ** Returns void
1294 **
1295 *******************************************************************************/
btif_hl_set_state(btif_hl_state_t state)1296 static void btif_hl_set_state(btif_hl_state_t state){
1297 BTIF_TRACE_DEBUG("btif_hl_set_state: %d ---> %d ", p_btif_hl_cb->state, state);
1298 p_btif_hl_cb->state = state;
1299 }
1300
1301 /*******************************************************************************
1302 **
1303 ** Function btif_hl_set_state
1304 **
1305 ** Description get HL state
1306 **
1307 ** Returns btif_hl_state_t
1308 **
1309 *******************************************************************************/
1310
btif_hl_get_state(void)1311 static btif_hl_state_t btif_hl_get_state(void){
1312 BTIF_TRACE_DEBUG("btif_hl_get_state: %d ", p_btif_hl_cb->state);
1313 return p_btif_hl_cb->state;
1314 }
1315
1316 /*******************************************************************************
1317 **
1318 ** Function btif_hl_find_data_type_idx
1319 **
1320 ** Description Find the index in the data type table
1321 **
1322 ** Returns BOOLEAN
1323 **
1324 *******************************************************************************/
btif_hl_find_data_type_idx(UINT16 data_type,UINT8 * p_idx)1325 static BOOLEAN btif_hl_find_data_type_idx(UINT16 data_type, UINT8 *p_idx){
1326 BOOLEAN found = FALSE;
1327 UINT8 i;
1328
1329 for (i=0; i< BTIF_HL_DATA_TABLE_SIZE; i++ )
1330 {
1331 if (data_type_table[i].data_type == data_type)
1332 {
1333 found = TRUE;
1334 *p_idx= i;
1335 break;
1336 }
1337 }
1338
1339 BTIF_TRACE_DEBUG("%s found=%d, data_type=0x%x idx=%d", __FUNCTION__, found, data_type, i);
1340 return found;
1341 }
1342
1343 /*******************************************************************************
1344 **
1345 ** Function btif_hl_get_max_tx_apdu_size
1346 **
1347 ** Description Find the maximum TX APDU size for the specified data type and
1348 ** MDEP role
1349 **
1350 ** Returns UINT16
1351 **
1352 *******************************************************************************/
btif_hl_get_max_tx_apdu_size(tBTA_HL_MDEP_ROLE mdep_role,UINT16 data_type)1353 UINT16 btif_hl_get_max_tx_apdu_size(tBTA_HL_MDEP_ROLE mdep_role,
1354 UINT16 data_type ){
1355 UINT8 idx;
1356 UINT16 max_tx_apdu_size =0;
1357
1358 if (btif_hl_find_data_type_idx(data_type, &idx))
1359 {
1360 if (mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
1361 {
1362 max_tx_apdu_size = data_type_table[idx].max_tx_apdu_size;
1363 }
1364 else
1365 {
1366 max_tx_apdu_size = data_type_table[idx].max_rx_apdu_size;
1367 }
1368 }
1369 else
1370 {
1371 if (mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
1372 {
1373 max_tx_apdu_size = BTIF_HL_DEFAULT_SRC_TX_APDU_SIZE;
1374 }
1375 else
1376 {
1377 max_tx_apdu_size = BTIF_HL_DEFAULT_SRC_RX_APDU_SIZE;
1378 }
1379
1380 }
1381
1382 BTIF_TRACE_DEBUG("%s mdep_role=%d data_type=0x%4x size=%d",
1383 __FUNCTION__, mdep_role, data_type, max_tx_apdu_size);
1384 return max_tx_apdu_size;
1385 }
1386
1387 /*******************************************************************************
1388 **
1389 ** Function btif_hl_get_max_rx_apdu_size
1390 **
1391 ** Description Find the maximum RX APDU size for the specified data type and
1392 ** MDEP role
1393 **
1394 ** Returns UINT16
1395 **
1396 *******************************************************************************/
btif_hl_get_max_rx_apdu_size(tBTA_HL_MDEP_ROLE mdep_role,UINT16 data_type)1397 UINT16 btif_hl_get_max_rx_apdu_size(tBTA_HL_MDEP_ROLE mdep_role,
1398 UINT16 data_type ){
1399 UINT8 idx;
1400 UINT16 max_rx_apdu_size =0;
1401
1402 if (btif_hl_find_data_type_idx(data_type, &idx))
1403 {
1404 if (mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
1405 {
1406 max_rx_apdu_size = data_type_table[idx].max_rx_apdu_size;
1407 }
1408 else
1409 {
1410 max_rx_apdu_size = data_type_table[idx].max_tx_apdu_size;
1411 }
1412 }
1413 else
1414 {
1415 if (mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
1416 {
1417 max_rx_apdu_size = BTIF_HL_DEFAULT_SRC_RX_APDU_SIZE;
1418 }
1419 else
1420 {
1421 max_rx_apdu_size = BTIF_HL_DEFAULT_SRC_TX_APDU_SIZE;
1422 }
1423 }
1424
1425 BTIF_TRACE_DEBUG("%s mdep_role=%d data_type=0x%4x size=%d",
1426 __FUNCTION__, mdep_role, data_type, max_rx_apdu_size);
1427
1428 return max_rx_apdu_size;
1429 }
1430
1431 /*******************************************************************************
1432 **
1433 ** Function btif_hl_if_channel_setup_pending
1434 **
1435 ** Description
1436 **
1437 ** Returns BOOLEAN
1438 **
1439 *******************************************************************************/
1440
btif_hl_get_bta_mdep_role(bthl_mdep_role_t mdep,tBTA_HL_MDEP_ROLE * p)1441 static BOOLEAN btif_hl_get_bta_mdep_role(bthl_mdep_role_t mdep, tBTA_HL_MDEP_ROLE *p){
1442 BOOLEAN status = TRUE;
1443 switch (mdep)
1444 {
1445 case BTHL_MDEP_ROLE_SOURCE:
1446 *p = BTA_HL_MDEP_ROLE_SOURCE;
1447 break;
1448 case BTHL_MDEP_ROLE_SINK:
1449 *p = BTA_HL_MDEP_ROLE_SINK;
1450 break;
1451 default:
1452 *p = BTA_HL_MDEP_ROLE_SOURCE;
1453 status = FALSE;
1454 break;
1455 }
1456
1457 BTIF_TRACE_DEBUG("%s status=%d bta_mdep_role=%d (%d:btif)",
1458 __FUNCTION__, status, *p, mdep);
1459 return status;
1460 }
1461 /*******************************************************************************
1462 **
1463 ** Function btif_hl_get_bta_channel_type
1464 **
1465 ** Description convert bthl channel type to BTA DCH channel type
1466 **
1467 ** Returns BOOLEAN
1468 **
1469 *******************************************************************************/
1470
btif_hl_get_bta_channel_type(bthl_channel_type_t channel_type,tBTA_HL_DCH_CFG * p)1471 static BOOLEAN btif_hl_get_bta_channel_type(bthl_channel_type_t channel_type, tBTA_HL_DCH_CFG *p){
1472 BOOLEAN status = TRUE;
1473 switch (channel_type)
1474 {
1475 case BTHL_CHANNEL_TYPE_RELIABLE:
1476 *p = BTA_HL_DCH_CFG_RELIABLE;
1477 break;
1478 case BTHL_CHANNEL_TYPE_STREAMING:
1479 *p = BTA_HL_DCH_CFG_STREAMING;
1480 break;
1481 case BTHL_CHANNEL_TYPE_ANY:
1482 *p = BTA_HL_DCH_CFG_NO_PREF;
1483 break;
1484 default:
1485 status = FALSE;
1486 break;
1487 }
1488 BTIF_TRACE_DEBUG("%s status = %d BTA DCH CFG=%d (1-rel 2-strm",
1489 __FUNCTION__, status, *p);
1490 return status;
1491 }
1492 /*******************************************************************************
1493 **
1494 ** Function btif_hl_get_next_app_id
1495 **
1496 ** Description get next applcation id
1497 **
1498 ** Returns UINT8
1499 **
1500 *******************************************************************************/
1501
btif_hl_get_next_app_id()1502 static UINT8 btif_hl_get_next_app_id(){
1503 UINT8 next_app_id = btif_hl_cb.next_app_id;
1504
1505 btif_hl_cb.next_app_id++;
1506 return next_app_id;
1507 }
1508 /*******************************************************************************
1509 **
1510 ** Function btif_hl_get_next_channel_id
1511 **
1512 ** Description get next channel id
1513 **
1514 ** Returns int
1515 **
1516 *******************************************************************************/
btif_hl_get_next_channel_id(UINT8 app_id)1517 static int btif_hl_get_next_channel_id(UINT8 app_id){
1518 UINT16 next_channel_id = btif_hl_cb.next_channel_id;
1519 int channel_id;
1520 btif_hl_cb.next_channel_id++;
1521 channel_id = (app_id << 16) + next_channel_id;
1522 BTIF_TRACE_DEBUG("%s channel_id=0x%08x, app_id=0x%02x next_channel_id=0x%04x", __FUNCTION__,
1523 channel_id, app_id, next_channel_id);
1524 return channel_id;
1525 }
1526 /*******************************************************************************
1527 **
1528 ** Function btif_hl_get_app_id
1529 **
1530 ** Description get the applicaiton id associated with the channel id
1531 **
1532 ** Returns UINT8
1533 **
1534 *******************************************************************************/
1535
btif_hl_get_app_id(int channel_id)1536 static UINT8 btif_hl_get_app_id(int channel_id){
1537 UINT8 app_id =(UINT8) (channel_id >> 16);
1538 BTIF_TRACE_DEBUG("%s channel_id=0x%08x, app_id=0x%02x ", __FUNCTION__,channel_id, app_id);
1539 return app_id;
1540 }
1541 /*******************************************************************************
1542 **
1543 ** Function btif_hl_init_next_app_id
1544 **
1545 ** Description initialize the application id
1546 **
1547 ** Returns void
1548 **
1549 *******************************************************************************/
btif_hl_init_next_app_id(void)1550 static void btif_hl_init_next_app_id(void){
1551 btif_hl_cb.next_app_id = 1;
1552 }
1553 /*******************************************************************************
1554 **
1555 ** Function btif_hl_init_next_channel_id
1556 **
1557 ** Description initialize the channel id
1558 **
1559 ** Returns void
1560 **
1561 *******************************************************************************/
btif_hl_init_next_channel_id(void)1562 static void btif_hl_init_next_channel_id(void){
1563 btif_hl_cb.next_channel_id = 1;
1564 }
1565
1566 /*******************************************************************************
1567 **
1568 ** Function btif_hl_find_app_idx_using_handle
1569 **
1570 ** Description Find the applicaiton index using handle
1571 **
1572 ** Returns BOOLEAN
1573 **
1574 *******************************************************************************/
btif_hl_find_app_idx_using_handle(tBTA_HL_APP_HANDLE app_handle,UINT8 * p_app_idx)1575 BOOLEAN btif_hl_find_app_idx_using_handle(tBTA_HL_APP_HANDLE app_handle,
1576 UINT8 *p_app_idx){
1577 BOOLEAN found=FALSE;
1578 UINT8 i;
1579
1580 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1581 {
1582 if (btif_hl_cb.acb[i].in_use &&
1583 (btif_hl_cb.acb[i].app_handle == app_handle))
1584 {
1585 found = TRUE;
1586 *p_app_idx = i;
1587 break;
1588 }
1589 }
1590
1591 BTIF_TRACE_EVENT("%s status=%d handle=%d app_idx=%d ",
1592 __FUNCTION__, found, app_handle , i);
1593
1594 return found;
1595 }
1596
1597 /*******************************************************************************
1598 **
1599 ** Function btif_hl_find_app_idx_using_app_id
1600 **
1601 ** Description Find the applicaiton index using app_id
1602 **
1603 ** Returns BOOLEAN
1604 **
1605 *******************************************************************************/
btif_hl_find_app_idx_using_app_id(UINT8 app_id,UINT8 * p_app_idx)1606 BOOLEAN btif_hl_find_app_idx_using_app_id(UINT8 app_id,
1607 UINT8 *p_app_idx){
1608 BOOLEAN found=FALSE;
1609 UINT8 i;
1610
1611 *p_app_idx = 0;
1612 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1613 {
1614 if (btif_hl_cb.acb[i].in_use &&
1615 (btif_hl_cb.acb[i].app_id == app_id))
1616 {
1617 found = TRUE;
1618 *p_app_idx = i;
1619 break;
1620 }
1621 }
1622
1623 BTIF_TRACE_EVENT("%s found=%d app_id=%d app_idx=%d ",
1624 __FUNCTION__, found, app_id , i);
1625
1626 return found;
1627 }
1628
1629 /*******************************************************************************
1630 **
1631 ** Function btif_hl_find_mcl_idx_using_handle
1632 **
1633 ** Description Find the MCL index using handle
1634 **
1635 ** Returns BOOLEAN
1636 **
1637 *******************************************************************************/
btif_hl_find_mcl_idx_using_handle(tBTA_HL_MCL_HANDLE mcl_handle,UINT8 * p_app_idx,UINT8 * p_mcl_idx)1638 BOOLEAN btif_hl_find_mcl_idx_using_handle( tBTA_HL_MCL_HANDLE mcl_handle,
1639 UINT8 *p_app_idx, UINT8 *p_mcl_idx){
1640 btif_hl_app_cb_t *p_acb;
1641 BOOLEAN found=FALSE;
1642 UINT8 i,j;
1643
1644 for (i=0; i<BTA_HL_NUM_APPS; i++)
1645 {
1646 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
1647 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
1648 {
1649 if (p_acb->mcb[j].in_use)
1650 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_handle:app_idx=%d,"
1651 "mcl_idx =%d mcl_handle=%d",i,j,p_acb->mcb[j].mcl_handle);
1652 if (p_acb->mcb[j].in_use &&
1653 (p_acb->mcb[j].mcl_handle == mcl_handle))
1654 {
1655 found = TRUE;
1656 *p_app_idx = i;
1657 *p_mcl_idx = j;
1658 break;
1659 }
1660 }
1661 }
1662 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d mcl_idx=%d",__FUNCTION__,
1663 found, i, j);
1664 return found;
1665 }
1666
1667 /*******************************************************************************
1668 **
1669 ** Function btif_hl_find_mdl_idx_using_mdl_id
1670 **
1671 ** Description Find the mdl index using mdl_id
1672 **
1673 ** Returns BOOLEAN
1674 **
1675 *******************************************************************************/
btif_hl_find_mcl_idx_using_mdl_id(UINT8 mdl_id,UINT8 mcl_handle,UINT8 * p_app_idx,UINT8 * p_mcl_idx)1676 BOOLEAN btif_hl_find_mcl_idx_using_mdl_id( UINT8 mdl_id,UINT8 mcl_handle,
1677 UINT8 *p_app_idx, UINT8 *p_mcl_idx){
1678 btif_hl_app_cb_t *p_acb;
1679 btif_hl_mcl_cb_t *p_mcb;
1680 BOOLEAN found=FALSE;
1681 UINT8 i,j,x;
1682
1683 for (i=0; i<BTA_HL_NUM_APPS; i++)
1684 {
1685 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
1686 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
1687 {
1688 if (p_acb->mcb[j].in_use &&
1689 (p_acb->mcb[j].mcl_handle == mcl_handle))
1690 {
1691 p_mcb = &p_acb->mcb[j];
1692 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_mdl_id: mcl handle found j =%d",j);
1693 for (x=0; x < BTA_HL_NUM_MDLS_PER_MCL ; x ++)
1694 {
1695 if (p_mcb->mdl[x].in_use && p_mcb->mdl[x].mdl_id == mdl_id)
1696 {
1697 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_mdl_id:found x =%d",x);
1698 found = TRUE;
1699 *p_app_idx = i;
1700 *p_mcl_idx = j;
1701 break;
1702 }
1703 }
1704 }
1705 }
1706 }
1707 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d mcl_idx=%d",__FUNCTION__,
1708 found, i, j);
1709 return found;
1710 }
1711
1712 /*******************************************************************************
1713 **
1714 ** Function btif_hl_find_mcl_idx_using_deleted_mdl_id
1715 **
1716 ** Description Find the app index deleted_mdl_id
1717 **
1718 ** Returns BOOLEAN
1719 **
1720 *******************************************************************************/
btif_hl_find_app_idx_using_deleted_mdl_id(UINT8 mdl_id,UINT8 * p_app_idx)1721 BOOLEAN btif_hl_find_app_idx_using_deleted_mdl_id( UINT8 mdl_id,
1722 UINT8 *p_app_idx){
1723 btif_hl_app_cb_t *p_acb;
1724 BOOLEAN found=FALSE;
1725 UINT8 i;
1726
1727 for (i=0; i<BTA_HL_NUM_APPS; i++)
1728 {
1729 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
1730 if (p_acb->delete_mdl.active) {
1731 BTIF_TRACE_DEBUG("%s: app_idx=%d, mdl_id=%d",
1732 __FUNCTION__,i,mdl_id);
1733 }
1734 if (p_acb->delete_mdl.active &&
1735 (p_acb->delete_mdl.mdl_id == mdl_id))
1736 {
1737 found = TRUE;
1738 *p_app_idx = i;
1739 break;
1740 }
1741 }
1742 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d",__FUNCTION__,
1743 found, i);
1744 return found;
1745 }
1746
1747 /*******************************************************************************
1748 **
1749 ** Function btif_hl_stop_timer_using_handle
1750 **
1751 ** Description clean control channel cb using handle
1752 **
1753 ** Returns void
1754 **
1755 *******************************************************************************/
btif_hl_stop_timer_using_handle(tBTA_HL_MCL_HANDLE mcl_handle)1756 static void btif_hl_stop_timer_using_handle( tBTA_HL_MCL_HANDLE mcl_handle){
1757 btif_hl_app_cb_t *p_acb;
1758 UINT8 i,j;
1759
1760 for (i=0; i<BTA_HL_NUM_APPS; i++)
1761 {
1762 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
1763 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
1764 {
1765 if (p_acb->mcb[j].in_use &&
1766 (p_acb->mcb[j].mcl_handle == mcl_handle))
1767 {
1768 btif_hl_stop_cch_timer(i, j);
1769 }
1770 }
1771 }
1772 }
1773
1774 /*******************************************************************************
1775 **
1776 ** Function btif_hl_find_mcl_idx_using_app_idx
1777 **
1778 ** Description Find the MCL index using handle
1779 **
1780 ** Returns BOOLEAN
1781 **
1782 *******************************************************************************/
btif_hl_find_mcl_idx_using_app_idx(tBTA_HL_MCL_HANDLE mcl_handle,UINT8 p_app_idx,UINT8 * p_mcl_idx)1783 BOOLEAN btif_hl_find_mcl_idx_using_app_idx( tBTA_HL_MCL_HANDLE mcl_handle,
1784 UINT8 p_app_idx, UINT8 *p_mcl_idx){
1785 btif_hl_app_cb_t *p_acb;
1786 BOOLEAN found=FALSE;
1787 UINT8 j;
1788
1789 p_acb =BTIF_HL_GET_APP_CB_PTR(p_app_idx);
1790 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
1791 {
1792 if (p_acb->mcb[j].in_use &&
1793 (p_acb->mcb[j].mcl_handle == mcl_handle))
1794 {
1795 found = TRUE;
1796 *p_mcl_idx = j;
1797 break;
1798 }
1799 }
1800 BTIF_TRACE_DEBUG("%s found=%dmcl_idx=%d",__FUNCTION__,
1801 found, j);
1802 return found;
1803 }
1804
1805 /*******************************************************************************
1806 **
1807 ** Function btif_hl_clean_mdls_using_app_idx
1808 **
1809 ** Description clean dch cpntrol bloack using app_idx
1810 **
1811 ** Returns void
1812 **
1813 *******************************************************************************/
btif_hl_clean_mdls_using_app_idx(UINT8 app_idx)1814 void btif_hl_clean_mdls_using_app_idx( UINT8 app_idx){
1815 btif_hl_app_cb_t *p_acb;
1816 btif_hl_mcl_cb_t *p_mcb;
1817 btif_hl_mdl_cb_t *p_dcb;
1818 UINT8 j,x,y;
1819 bt_bdaddr_t bd_addr;
1820
1821 p_acb =BTIF_HL_GET_APP_CB_PTR(app_idx);
1822 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
1823 {
1824 if (p_acb->mcb[j].in_use)
1825 {
1826 p_mcb = &p_acb->mcb[j];
1827 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_mdl_id: mcl handle found j =%d",j);
1828 for (x=0; x < BTA_HL_NUM_MDLS_PER_MCL ; x ++)
1829 {
1830 if (p_mcb->mdl[x].in_use)
1831 {
1832 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, j,x);
1833 btif_hl_release_socket(app_idx,j,x);
1834 for (y=0; y<6; y++)
1835 {
1836 bd_addr.address[y] = p_mcb->bd_addr[y];
1837 }
1838 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, p_acb->app_id,
1839 &bd_addr, p_dcb->local_mdep_cfg_idx,
1840 p_dcb->channel_id, BTHL_CONN_STATE_DISCONNECTED, 0 );
1841 btif_hl_clean_mdl_cb(p_dcb);
1842 if (!btif_hl_num_dchs_in_use(p_mcb->mcl_handle))
1843 BTA_HlCchClose(p_mcb->mcl_handle);
1844 BTIF_TRACE_DEBUG("remote DCH close success mdl_idx=%d", x);
1845 }
1846 }
1847 }
1848 }
1849 }
1850
1851 /*******************************************************************************
1852 **
1853 ** Function btif_hl_find_app_idx
1854 **
1855 ** Description Find the application index using application ID
1856 **
1857 ** Returns BOOLEAN
1858 **
1859 *******************************************************************************/
btif_hl_find_app_idx(UINT8 app_id,UINT8 * p_app_idx)1860 BOOLEAN btif_hl_find_app_idx(UINT8 app_id, UINT8 *p_app_idx){
1861 BOOLEAN found=FALSE;
1862 UINT8 i;
1863
1864 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1865 {
1866
1867 if (btif_hl_cb.acb[i].in_use &&
1868 (btif_hl_cb.acb[i].app_id == app_id))
1869 {
1870 found = TRUE;
1871 *p_app_idx = i;
1872 break;
1873 }
1874 }
1875 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d", __FUNCTION__, found, i );
1876
1877 return found;
1878 }
1879
1880 /*******************************************************************************
1881 **
1882 ** Function btif_hl_find_app_idx
1883 **
1884 ** Description Find the application index using application ID
1885 **
1886 ** Returns BOOLEAN
1887 **
1888 *******************************************************************************/
btif_hl_find_app_idx_using_mdepId(UINT8 mdep_id,UINT8 * p_app_idx)1889 BOOLEAN btif_hl_find_app_idx_using_mdepId(UINT8 mdep_id, UINT8 *p_app_idx){
1890 BOOLEAN found=FALSE;
1891 UINT8 i;
1892
1893 *p_app_idx = 0;
1894 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1895 {
1896 BTIF_TRACE_DEBUG("btif_hl_find_app_idx_using_mdepId: MDEP-ID = %d",
1897 btif_hl_cb.acb[i].sup_feature.mdep[0].mdep_id);
1898 if (btif_hl_cb.acb[i].in_use &&
1899 (btif_hl_cb.acb[i].sup_feature.mdep[0].mdep_id == mdep_id))
1900 {
1901 found = TRUE;
1902 *p_app_idx = i;
1903 break;
1904 }
1905 }
1906 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d", __FUNCTION__, found, i );
1907
1908 return found;
1909 }
1910
1911 /*******************************************************************************
1912 **
1913 ** Function btif_hl_find_avail_mdl_idx
1914 **
1915 ** Description Find a not in-use MDL index
1916 **
1917 ** Returns BOOLEAN
1918 **
1919 *******************************************************************************/
btif_hl_find_avail_mdl_idx(UINT8 app_idx,UINT8 mcl_idx,UINT8 * p_mdl_idx)1920 BOOLEAN btif_hl_find_avail_mdl_idx(UINT8 app_idx, UINT8 mcl_idx,
1921 UINT8 *p_mdl_idx){
1922 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1923 BOOLEAN found=FALSE;
1924 UINT8 i;
1925
1926 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
1927 {
1928 if (!p_mcb->mdl[i].in_use)
1929 {
1930 btif_hl_clean_mdl_cb(&p_mcb->mdl[i]);
1931 found = TRUE;
1932 *p_mdl_idx = i;
1933 break;
1934 }
1935 }
1936
1937 BTIF_TRACE_DEBUG("%s found=%d idx=%d",__FUNCTION__, found, i);
1938 return found;
1939 }
1940
1941 /*******************************************************************************
1942 **
1943 ** Function btif_hl_find_avail_mcl_idx
1944 **
1945 ** Description Find a not in-use MDL index
1946 **
1947 ** Returns BOOLEAN
1948 **
1949 *******************************************************************************/
btif_hl_find_avail_mcl_idx(UINT8 app_idx,UINT8 * p_mcl_idx)1950 BOOLEAN btif_hl_find_avail_mcl_idx(UINT8 app_idx, UINT8 *p_mcl_idx){
1951 BOOLEAN found=FALSE;
1952 UINT8 i;
1953
1954 for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
1955 {
1956 if (!btif_hl_cb.acb[app_idx].mcb[i].in_use)
1957 {
1958 found = TRUE;
1959 *p_mcl_idx = i;
1960 break;
1961 }
1962 }
1963 BTIF_TRACE_DEBUG("%s found=%d mcl_idx=%d", __FUNCTION__, found, i);
1964 return found;
1965 }
1966
1967 /*******************************************************************************
1968 **
1969 ** Function btif_hl_find_avail_app_idx
1970 **
1971 ** Description Find a not in-use APP index
1972 **
1973 ** Returns BOOLEAN
1974 **
1975 *******************************************************************************/
btif_hl_find_avail_app_idx(UINT8 * p_idx)1976 static BOOLEAN btif_hl_find_avail_app_idx(UINT8 *p_idx){
1977 BOOLEAN found = FALSE;
1978 UINT8 i;
1979
1980 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1981 {
1982 if (!btif_hl_cb.acb[i].in_use)
1983 {
1984 found = TRUE;
1985 *p_idx = i;
1986 break;
1987 }
1988 }
1989
1990 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d", __FUNCTION__, found, i);
1991 return found;
1992 }
1993
1994 /*******************************************************************************
1995 **
1996 ** Function btif_hl_proc_dereg_cfm
1997 **
1998 ** Description Process the de-registration confirmation
1999 **
2000 ** Returns Nothing
2001 **
2002 *******************************************************************************/
btif_hl_proc_dereg_cfm(tBTA_HL * p_data)2003 static void btif_hl_proc_dereg_cfm(tBTA_HL *p_data)
2004
2005 {
2006 btif_hl_app_cb_t *p_acb;
2007 UINT8 app_idx;
2008 int app_id = 0;
2009 bthl_app_reg_state_t state = BTHL_APP_REG_STATE_DEREG_SUCCESS;
2010
2011 BTIF_TRACE_DEBUG("%s de-reg status=%d app_handle=%d", __FUNCTION__,
2012 p_data->dereg_cfm.status, p_data->dereg_cfm.app_handle);
2013
2014 if (btif_hl_find_app_idx_using_app_id(p_data->dereg_cfm.app_id, &app_idx))
2015 {
2016 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
2017 app_id = (int) p_acb->app_id;
2018 if (p_data->dereg_cfm.status == BTA_HL_STATUS_OK)
2019 {
2020 btif_hl_clean_mdls_using_app_idx(app_idx);
2021 for (size_t i = 0; i < BTA_HL_NUM_MCLS; i++)
2022 alarm_free(p_acb->mcb[i].cch_timer);
2023 memset(p_acb, 0, sizeof(btif_hl_app_cb_t));
2024 }
2025 else
2026 state = BTHL_APP_REG_STATE_DEREG_FAILED;
2027
2028 BTIF_TRACE_DEBUG("call reg state callback app_id=%d state=%d", app_id, state);
2029 BTIF_HL_CALL_CBACK(bt_hl_callbacks, app_reg_state_cb, app_id, state );
2030
2031 if (btif_hl_is_no_active_app())
2032 {
2033 btif_hl_disable();
2034 }
2035 }
2036 }
2037
2038 /*******************************************************************************
2039 **
2040 ** Function btif_hl_proc_reg_cfm
2041 **
2042 ** Description Process the registration confirmation
2043 **
2044 ** Returns Nothing
2045 **
2046 *******************************************************************************/
btif_hl_proc_reg_cfm(tBTA_HL * p_data)2047 static void btif_hl_proc_reg_cfm(tBTA_HL *p_data){
2048 btif_hl_app_cb_t *p_acb;
2049 UINT8 app_idx;
2050 bthl_app_reg_state_t state = BTHL_APP_REG_STATE_REG_SUCCESS;
2051
2052 BTIF_TRACE_DEBUG("%s reg status=%d app_handle=%d", __FUNCTION__, p_data->reg_cfm.status, p_data->reg_cfm.app_handle);
2053
2054 if (btif_hl_find_app_idx(p_data->reg_cfm.app_id, &app_idx))
2055 {
2056 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
2057 if (p_data->reg_cfm.status == BTA_HL_STATUS_OK)
2058 {
2059 p_acb->app_handle = p_data->reg_cfm.app_handle;
2060 }
2061 else
2062 {
2063 btif_hl_free_app_idx(app_idx);
2064 reg_counter--;
2065 state = BTHL_APP_REG_STATE_REG_FAILED;
2066 }
2067
2068 BTIF_TRACE_DEBUG("%s call reg state callback app_id=%d reg state=%d", __FUNCTION__, p_data->reg_cfm.app_id, state);
2069 BTIF_HL_CALL_CBACK(bt_hl_callbacks, app_reg_state_cb, ((int) p_data->reg_cfm.app_id), state );
2070 }
2071 }
2072
2073 /*******************************************************************************
2074 **
2075 ** Function btif_hl_set_chan_cb_state
2076 **
2077 ** Description set the channel callback state
2078 **
2079 ** Returns void
2080 **
2081 *******************************************************************************/
btif_hl_set_chan_cb_state(UINT8 app_idx,UINT8 mcl_idx,btif_hl_chan_cb_state_t state)2082 void btif_hl_set_chan_cb_state(UINT8 app_idx, UINT8 mcl_idx, btif_hl_chan_cb_state_t state){
2083 btif_hl_pending_chan_cb_t *p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
2084 btif_hl_chan_cb_state_t cur_state = p_pcb->cb_state;
2085
2086 if (cur_state != state)
2087 {
2088 p_pcb->cb_state = state;
2089 BTIF_TRACE_DEBUG("%s state %d--->%d",__FUNCTION__, cur_state, state);
2090 }
2091
2092 }
2093 /*******************************************************************************
2094 **
2095 ** Function btif_hl_send_destroyed_cb
2096 **
2097 ** Description send the channel destroyed callback
2098 **
2099 ** Returns void
2100 **
2101 *******************************************************************************/
btif_hl_send_destroyed_cb(btif_hl_app_cb_t * p_acb)2102 void btif_hl_send_destroyed_cb(btif_hl_app_cb_t *p_acb ){
2103 bt_bdaddr_t bd_addr;
2104 int app_id = (int) btif_hl_get_app_id(p_acb->delete_mdl.channel_id);
2105
2106 btif_hl_copy_bda(&bd_addr, p_acb->delete_mdl.bd_addr);
2107 BTIF_TRACE_DEBUG("%s",__FUNCTION__);
2108 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,
2109 p_acb->delete_mdl.mdep_cfg_idx, BTHL_CONN_STATE_DESTROYED, 0);
2110 btif_hl_display_bt_bda(&bd_addr);
2111
2112 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id,
2113 &bd_addr, p_acb->delete_mdl.mdep_cfg_idx,
2114 p_acb->delete_mdl.channel_id, BTHL_CONN_STATE_DESTROYED, 0 );
2115 }
2116 /*******************************************************************************
2117 **
2118 ** Function btif_hl_send_disconnecting_cb
2119 **
2120 ** Description send a channel disconnecting callback
2121 **
2122 ** Returns void
2123 **
2124 *******************************************************************************/
btif_hl_send_disconnecting_cb(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdl_idx)2125 void btif_hl_send_disconnecting_cb(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx){
2126 btif_hl_mdl_cb_t *p_dcb = BTIF_HL_GET_MDL_CB_PTR( app_idx, mcl_idx, mdl_idx);
2127 btif_hl_soc_cb_t *p_scb = p_dcb->p_scb;
2128 bt_bdaddr_t bd_addr;
2129 int app_id = (int) btif_hl_get_app_id(p_scb->channel_id);
2130
2131 btif_hl_copy_bda(&bd_addr, p_scb->bd_addr);
2132
2133 BTIF_TRACE_DEBUG("%s",__FUNCTION__);
2134 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d, state=%d fd=%d",p_scb->channel_id,
2135 p_scb->mdep_cfg_idx, BTHL_CONN_STATE_DISCONNECTING, p_scb->socket_id[0]);
2136 btif_hl_display_bt_bda(&bd_addr);
2137 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id,
2138 &bd_addr, p_scb->mdep_cfg_idx,
2139 p_scb->channel_id, BTHL_CONN_STATE_DISCONNECTING, p_scb->socket_id[0] );
2140 }
2141 /*******************************************************************************
2142 **
2143 ** Function btif_hl_send_setup_connecting_cb
2144 **
2145 ** Description send a channel connecting callback
2146 **
2147 ** Returns void
2148 **
2149 *******************************************************************************/
btif_hl_send_setup_connecting_cb(UINT8 app_idx,UINT8 mcl_idx)2150 void btif_hl_send_setup_connecting_cb(UINT8 app_idx, UINT8 mcl_idx){
2151 btif_hl_pending_chan_cb_t *p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
2152 bt_bdaddr_t bd_addr;
2153 int app_id = (int) btif_hl_get_app_id(p_pcb->channel_id);
2154
2155 btif_hl_copy_bda(&bd_addr, p_pcb->bd_addr);
2156
2157 if (p_pcb->in_use && p_pcb->cb_state == BTIF_HL_CHAN_CB_STATE_CONNECTING_PENDING)
2158 {
2159 BTIF_TRACE_DEBUG("%s",__FUNCTION__);
2160 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d state=%d fd=%d",p_pcb->channel_id,
2161 p_pcb->mdep_cfg_idx, BTHL_CONN_STATE_CONNECTING, 0);
2162 btif_hl_display_bt_bda(&bd_addr);
2163
2164 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id,
2165 &bd_addr, p_pcb->mdep_cfg_idx,
2166 p_pcb->channel_id, BTHL_CONN_STATE_CONNECTING, 0 );
2167 btif_hl_set_chan_cb_state(app_idx, mcl_idx, BTIF_HL_CHAN_CB_STATE_CONNECTED_PENDING);
2168 }
2169 }
2170 /*******************************************************************************
2171 **
2172 ** Function btif_hl_send_setup_disconnected_cb
2173 **
2174 ** Description send a channel disconnected callback
2175 **
2176 ** Returns void
2177 **
2178 *******************************************************************************/
btif_hl_send_setup_disconnected_cb(UINT8 app_idx,UINT8 mcl_idx)2179 void btif_hl_send_setup_disconnected_cb(UINT8 app_idx, UINT8 mcl_idx){
2180 btif_hl_pending_chan_cb_t *p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
2181 bt_bdaddr_t bd_addr;
2182 int app_id = (int) btif_hl_get_app_id(p_pcb->channel_id);
2183
2184 btif_hl_copy_bda(&bd_addr, p_pcb->bd_addr);
2185
2186 BTIF_TRACE_DEBUG("%s p_pcb->in_use=%d",__FUNCTION__, p_pcb->in_use);
2187 if (p_pcb->in_use)
2188 {
2189 BTIF_TRACE_DEBUG("%p_pcb->cb_state=%d",p_pcb->cb_state);
2190 if (p_pcb->cb_state == BTIF_HL_CHAN_CB_STATE_CONNECTING_PENDING)
2191 {
2192 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d state=%d fd=%d",p_pcb->channel_id,
2193 p_pcb->mdep_cfg_idx, BTHL_CONN_STATE_CONNECTING, 0);
2194 btif_hl_display_bt_bda(&bd_addr);
2195 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id,
2196 &bd_addr, p_pcb->mdep_cfg_idx,
2197 p_pcb->channel_id, BTHL_CONN_STATE_CONNECTING, 0 );
2198
2199 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d state=%d fd=%d",p_pcb->channel_id,
2200 p_pcb->mdep_cfg_idx, BTHL_CONN_STATE_DISCONNECTED, 0);
2201 btif_hl_display_bt_bda(&bd_addr);
2202 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id,
2203 &bd_addr, p_pcb->mdep_cfg_idx,
2204 p_pcb->channel_id, BTHL_CONN_STATE_DISCONNECTED, 0 );
2205 }
2206 else if (p_pcb->cb_state == BTIF_HL_CHAN_CB_STATE_CONNECTED_PENDING)
2207 {
2208 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d state=%d fd=%d",p_pcb->channel_id,
2209 p_pcb->mdep_cfg_idx, BTHL_CONN_STATE_DISCONNECTED, 0);
2210 btif_hl_display_bt_bda(&bd_addr);
2211 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id,
2212 &bd_addr, p_pcb->mdep_cfg_idx,
2213 p_pcb->channel_id, BTHL_CONN_STATE_DISCONNECTED, 0 );
2214 }
2215 btif_hl_clean_pcb(p_pcb);
2216 }
2217 }
2218 /*******************************************************************************
2219 **
2220 ** Function btif_hl_proc_sdp_query_cfm
2221 **
2222 ** Description Process the SDP query confirmation
2223 **
2224 ** Returns Nothing
2225 **
2226 *******************************************************************************/
btif_hl_proc_sdp_query_cfm(tBTA_HL * p_data)2227 static BOOLEAN btif_hl_proc_sdp_query_cfm(tBTA_HL *p_data){
2228 btif_hl_app_cb_t *p_acb;
2229 btif_hl_mcl_cb_t *p_mcb;
2230 tBTA_HL_SDP *p_sdp;
2231 tBTA_HL_CCH_OPEN_PARAM open_param;
2232 UINT8 app_idx, mcl_idx, sdp_idx = 0;
2233 UINT8 num_recs, i, num_mdeps, j;
2234 btif_hl_cch_op_t old_cch_oper;
2235 BOOLEAN status =FALSE;
2236 btif_hl_pending_chan_cb_t *p_pcb;
2237
2238 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2239
2240 p_sdp = p_data->sdp_query_cfm.p_sdp;
2241 num_recs = p_sdp->num_recs;
2242
2243 BTIF_TRACE_DEBUG("num of SDP records=%d",num_recs);
2244 for (i=0; i<num_recs; i++)
2245 {
2246 BTIF_TRACE_DEBUG("rec_idx=%d ctrl_psm=0x%x data_psm=0x%x",
2247 (i+1),p_sdp->sdp_rec[i].ctrl_psm, p_sdp->sdp_rec[i].data_psm);
2248 BTIF_TRACE_DEBUG("MCAP supported procedures=0x%x",p_sdp->sdp_rec[i].mcap_sup_proc);
2249 num_mdeps = p_sdp->sdp_rec[i].num_mdeps;
2250 BTIF_TRACE_DEBUG("num of mdeps =%d",num_mdeps);
2251 for (j=0; j< num_mdeps; j++)
2252 {
2253 BTIF_TRACE_DEBUG("mdep_idx=%d mdep_id=0x%x data_type=0x%x mdep_role=0x%x",
2254 (j+1),
2255 p_sdp->sdp_rec[i].mdep_cfg[j].mdep_id,
2256 p_sdp->sdp_rec[i].mdep_cfg[j].data_type,
2257 p_sdp->sdp_rec[i].mdep_cfg[j].mdep_role );
2258 }
2259 }
2260
2261 if (btif_hl_find_app_idx_using_app_id(p_data->sdp_query_cfm.app_id, &app_idx))
2262 {
2263 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
2264
2265 if (btif_hl_find_mcl_idx(app_idx, p_data->sdp_query_cfm.bd_addr, &mcl_idx))
2266 {
2267 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2268 if (p_mcb->cch_oper != BTIF_HL_CCH_OP_NONE)
2269 {
2270 memcpy(&p_mcb->sdp, p_sdp, sizeof(tBTA_HL_SDP));
2271 old_cch_oper = p_mcb->cch_oper;
2272 p_mcb->cch_oper = BTIF_HL_CCH_OP_NONE;
2273
2274 switch (old_cch_oper)
2275 {
2276 case BTIF_HL_CCH_OP_MDEP_FILTERING:
2277 status = btif_hl_find_sdp_idx_using_mdep_filter(app_idx,
2278 mcl_idx, &sdp_idx);
2279 break;
2280 default:
2281 break;
2282 }
2283
2284 if (status)
2285 {
2286 p_mcb->sdp_idx = sdp_idx;
2287 p_mcb->valid_sdp_idx = TRUE;
2288 p_mcb->ctrl_psm = p_mcb->sdp.sdp_rec[sdp_idx].ctrl_psm;
2289
2290 switch (old_cch_oper)
2291 {
2292 case BTIF_HL_CCH_OP_MDEP_FILTERING:
2293 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
2294 if (p_pcb->in_use)
2295 {
2296 if (!p_pcb->abort_pending)
2297 {
2298 switch (p_pcb->op)
2299 {
2300 case BTIF_HL_PEND_DCH_OP_OPEN:
2301 btif_hl_send_setup_connecting_cb(app_idx, mcl_idx);
2302 break;
2303 case BTIF_HL_PEND_DCH_OP_DELETE_MDL:
2304 default:
2305 break;
2306 }
2307 open_param.ctrl_psm = p_mcb->ctrl_psm;
2308 bdcpy(open_param.bd_addr, p_mcb->bd_addr);
2309 open_param.sec_mask =
2310 (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT);
2311 BTA_HlCchOpen(p_acb->app_id,p_acb->app_handle, &open_param);
2312 }
2313 else
2314 {
2315 BTIF_TRACE_DEBUG("channel abort pending");
2316 }
2317 }
2318 break;
2319
2320 case BTIF_HL_CCH_OP_DCH_OPEN:
2321 status = btif_hl_proc_pending_op(app_idx,mcl_idx);
2322 break;
2323
2324 default:
2325 BTIF_TRACE_ERROR("Invalid CCH oper %d", old_cch_oper);
2326 break;
2327 }
2328 }
2329 else
2330 {
2331 BTIF_TRACE_ERROR("Can not find SDP idx discard CCH Open request");
2332 }
2333 }
2334 }
2335 }
2336 return status;
2337 }
2338
2339 /*******************************************************************************
2340 **
2341 ** Function btif_hl_proc_cch_open_ind
2342 **
2343 ** Description Process the CCH open indication
2344 **
2345 ** Returns Nothing
2346 **
2347 *******************************************************************************/
btif_hl_proc_cch_open_ind(tBTA_HL * p_data)2348 static void btif_hl_proc_cch_open_ind(tBTA_HL *p_data)
2349
2350 {
2351 btif_hl_mcl_cb_t *p_mcb;
2352 UINT8 mcl_idx;
2353 int i;
2354
2355 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2356 for(i=0; i<BTA_HL_NUM_APPS; i++)
2357 {
2358 if (btif_hl_cb.acb[i].in_use)
2359 {
2360 if (!btif_hl_find_mcl_idx(i, p_data->cch_open_ind.bd_addr, &mcl_idx))
2361 {
2362 if (btif_hl_find_avail_mcl_idx(i, &mcl_idx))
2363 {
2364 p_mcb = BTIF_HL_GET_MCL_CB_PTR(i, mcl_idx);
2365 alarm_free(p_mcb->cch_timer);
2366 memset(p_mcb, 0, sizeof(btif_hl_mcl_cb_t));
2367 p_mcb->in_use = TRUE;
2368 p_mcb->is_connected = TRUE;
2369 p_mcb->mcl_handle = p_data->cch_open_ind.mcl_handle;
2370 bdcpy(p_mcb->bd_addr, p_data->cch_open_ind.bd_addr);
2371 btif_hl_start_cch_timer(i, mcl_idx);
2372 }
2373 }
2374 else
2375 {
2376 BTIF_TRACE_ERROR("The MCL already exist for cch_open_ind");
2377 }
2378 }
2379 }
2380 }
2381
2382 /*******************************************************************************
2383 **
2384 ** Function btif_hl_proc_pending_op
2385 **
2386 ** Description Process the pending dch operation.
2387 **
2388 ** Returns Nothing
2389 **
2390 *******************************************************************************/
btif_hl_proc_pending_op(UINT8 app_idx,UINT8 mcl_idx)2391 BOOLEAN btif_hl_proc_pending_op(UINT8 app_idx, UINT8 mcl_idx)
2392
2393 {
2394
2395 btif_hl_app_cb_t *p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
2396 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2397 btif_hl_pending_chan_cb_t *p_pcb;
2398 BOOLEAN status = FALSE;
2399 tBTA_HL_DCH_OPEN_PARAM dch_open;
2400 tBTA_HL_MDL_ID mdl_id;
2401 tBTA_HL_DCH_RECONNECT_PARAM reconnect_param;
2402
2403 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
2404 if (p_pcb->in_use)
2405 {
2406 switch (p_pcb->op)
2407 {
2408 case BTIF_HL_PEND_DCH_OP_OPEN:
2409 if (!p_pcb->abort_pending)
2410 {
2411 BTIF_TRACE_DEBUG("op BTIF_HL_PEND_DCH_OP_OPEN");
2412 dch_open.ctrl_psm = p_mcb->ctrl_psm;
2413 dch_open.local_mdep_id = p_acb->sup_feature.mdep[p_pcb->mdep_cfg_idx].mdep_id;
2414 if (btif_hl_find_peer_mdep_id(p_acb->app_id, p_mcb->bd_addr,
2415 p_acb->sup_feature.mdep[p_pcb->mdep_cfg_idx].mdep_cfg.mdep_role,
2416 p_acb->sup_feature.mdep[p_pcb->mdep_cfg_idx].mdep_cfg.data_cfg[0].data_type, &dch_open.peer_mdep_id ))
2417 {
2418 dch_open.local_cfg = p_acb->channel_type[p_pcb->mdep_cfg_idx];
2419 if ((p_acb->sup_feature.mdep[p_pcb->mdep_cfg_idx].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
2420 && !btif_hl_is_the_first_reliable_existed(app_idx, mcl_idx))
2421 {
2422 dch_open.local_cfg = BTA_HL_DCH_CFG_RELIABLE;
2423 }
2424 dch_open.sec_mask = (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT);
2425 BTIF_TRACE_DEBUG("dch_open.local_cfg=%d ", dch_open.local_cfg);
2426 btif_hl_send_setup_connecting_cb(app_idx,mcl_idx);
2427
2428 if (!btif_hl_is_reconnect_possible(app_idx, mcl_idx, p_pcb->mdep_cfg_idx, &dch_open, &mdl_id ))
2429 {
2430 BTIF_TRACE_DEBUG("Issue DCH open, mcl_handle=%d",p_mcb->mcl_handle);
2431 BTA_HlDchOpen(p_mcb->mcl_handle, &dch_open);
2432 }
2433 else
2434 {
2435 reconnect_param.ctrl_psm = p_mcb->ctrl_psm;
2436 reconnect_param.mdl_id = mdl_id;;
2437 BTIF_TRACE_DEBUG("Issue Reconnect ctrl_psm=0x%x mdl_id=0x%x",reconnect_param.ctrl_psm, reconnect_param.mdl_id);
2438 BTA_HlDchReconnect(p_mcb->mcl_handle, &reconnect_param);
2439 }
2440 status = TRUE;
2441 }
2442 }
2443 else
2444 {
2445 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx);
2446 status = TRUE;
2447 }
2448 break;
2449 case BTIF_HL_PEND_DCH_OP_DELETE_MDL:
2450 BTA_HlDeleteMdl(p_mcb->mcl_handle, p_acb->delete_mdl.mdl_id);
2451 status = TRUE;
2452 break;
2453
2454 default:
2455 break;
2456 }
2457 }
2458 return status;
2459 }
2460
2461 /*******************************************************************************
2462 **
2463 ** Function btif_hl_proc_cch_open_cfm
2464 **
2465 ** Description Process the CCH open confirmation
2466 **
2467 ** Returns Nothing
2468 **
2469 *******************************************************************************/
btif_hl_proc_cch_open_cfm(tBTA_HL * p_data)2470 static BOOLEAN btif_hl_proc_cch_open_cfm(tBTA_HL *p_data)
2471
2472 {
2473 btif_hl_mcl_cb_t *p_mcb;
2474 UINT8 app_idx, mcl_idx;
2475 BOOLEAN status = FALSE;
2476
2477 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2478
2479 if (btif_hl_find_app_idx_using_app_id(p_data->cch_open_cfm.app_id, &app_idx))
2480 {
2481 BTIF_TRACE_DEBUG("app_idx=%d", app_idx);
2482 if (btif_hl_find_mcl_idx(app_idx, p_data->cch_open_cfm.bd_addr, &mcl_idx))
2483 {
2484 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2485 BTIF_TRACE_DEBUG("mcl_idx=%d, mcl_handle=%d", mcl_idx,p_data->cch_open_cfm.mcl_handle);
2486 p_mcb->mcl_handle = p_data->cch_open_cfm.mcl_handle;
2487 p_mcb->is_connected = TRUE;
2488 status = btif_hl_proc_pending_op(app_idx, mcl_idx);
2489 if (status)
2490 btif_hl_start_cch_timer(app_idx, mcl_idx);
2491 }
2492 }
2493
2494 return status;
2495 }
2496
2497 /*******************************************************************************
2498 **
2499 ** Function btif_hl_clean_mcb_using_handle
2500 **
2501 ** Description clean control channel cb using handle
2502 **
2503 ** Returns void
2504 **
2505 *******************************************************************************/
btif_hl_clean_mcb_using_handle(tBTA_HL_MCL_HANDLE mcl_handle)2506 static void btif_hl_clean_mcb_using_handle( tBTA_HL_MCL_HANDLE mcl_handle){
2507 btif_hl_app_cb_t *p_acb;
2508 UINT8 i,j;
2509
2510 for (i=0; i<BTA_HL_NUM_APPS; i++)
2511 {
2512 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
2513 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
2514 {
2515 if (p_acb->mcb[j].in_use)
2516 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_handle: app_idx=%d,"
2517 "mcl_idx =%d mcl_handle=%d",i,j,p_acb->mcb[j].mcl_handle);
2518 if (p_acb->mcb[j].in_use &&
2519 (p_acb->mcb[j].mcl_handle == mcl_handle))
2520 {
2521 btif_hl_stop_cch_timer(i, j);
2522 btif_hl_release_mcl_sockets(i, j);
2523 btif_hl_send_setup_disconnected_cb(i, j);
2524 btif_hl_clean_mcl_cb(i, j);
2525 }
2526 }
2527 }
2528 }
2529
2530 /*******************************************************************************
2531 **
2532 ** Function btif_hl_proc_cch_close_ind
2533 **
2534 ** Description Process the CCH close indication
2535 **
2536 ** Returns Nothing
2537 **
2538 *******************************************************************************/
btif_hl_proc_cch_close_ind(tBTA_HL * p_data)2539 static void btif_hl_proc_cch_close_ind(tBTA_HL *p_data)
2540
2541 {
2542 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2543
2544 btif_hl_clean_mcb_using_handle(p_data->cch_close_ind.mcl_handle);
2545 }
2546
2547 /*******************************************************************************
2548 **
2549 ** Function btif_hl_proc_cch_close_cfm
2550 **
2551 ** Description Process the CCH close confirmation
2552 **
2553 ** Returns Nothing
2554 **
2555 *******************************************************************************/
btif_hl_proc_cch_close_cfm(tBTA_HL * p_data)2556 static void btif_hl_proc_cch_close_cfm(tBTA_HL *p_data)
2557 {
2558 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2559
2560 btif_hl_clean_mcb_using_handle(p_data->cch_close_ind.mcl_handle);
2561 }
2562
2563 /*******************************************************************************
2564 **
2565 ** Function btif_hl_proc_create_ind
2566 **
2567 ** Description Process the MDL create indication
2568 **
2569 ** Returns Nothing
2570 **
2571 *******************************************************************************/
btif_hl_proc_create_ind(tBTA_HL * p_data)2572 static void btif_hl_proc_create_ind(tBTA_HL *p_data){
2573 btif_hl_app_cb_t *p_acb;
2574 btif_hl_mcl_cb_t *p_mcb;
2575 tBTA_HL_MDEP *p_mdep;
2576 UINT8 orig_app_idx, mcl_idx, mdep_cfg_idx;
2577 BOOLEAN first_reliable_exist;
2578 BOOLEAN success = TRUE;
2579 tBTA_HL_DCH_CFG rsp_cfg = BTA_HL_DCH_CFG_UNKNOWN;
2580 tBTA_HL_DCH_CREATE_RSP rsp_code = BTA_HL_DCH_CREATE_RSP_CFG_REJ;
2581 tBTA_HL_DCH_CREATE_RSP_PARAM create_rsp_param;
2582
2583 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2584
2585 // Find the correct app_idx based on the mdep_id;
2586 btif_hl_find_app_idx_using_mdepId(p_data->dch_create_ind.local_mdep_id,&orig_app_idx);
2587 if (btif_hl_find_mcl_idx(orig_app_idx, p_data->dch_create_ind.bd_addr, &mcl_idx))
2588 {
2589 p_acb =BTIF_HL_GET_APP_CB_PTR(orig_app_idx);
2590 p_mcb =BTIF_HL_GET_MCL_CB_PTR(orig_app_idx, mcl_idx);
2591
2592 if (btif_hl_find_mdep_cfg_idx(orig_app_idx, p_data->dch_create_ind.local_mdep_id, &mdep_cfg_idx))
2593 {
2594 p_mdep = &(p_acb->sup_feature.mdep[mdep_cfg_idx]);
2595 first_reliable_exist = btif_hl_is_the_first_reliable_existed(orig_app_idx, mcl_idx);
2596 switch (p_mdep->mdep_cfg.mdep_role)
2597 {
2598 case BTA_HL_MDEP_ROLE_SOURCE:
2599 if (p_data->dch_create_ind.cfg == BTA_HL_DCH_CFG_NO_PREF)
2600 {
2601 if (first_reliable_exist)
2602 {
2603 rsp_cfg = p_acb->channel_type[mdep_cfg_idx];
2604 }
2605 else
2606 {
2607 rsp_cfg = BTA_HL_DCH_CFG_RELIABLE;
2608 }
2609 rsp_code = BTA_HL_DCH_CREATE_RSP_SUCCESS;
2610 }
2611
2612 break;
2613 case BTA_HL_MDEP_ROLE_SINK:
2614
2615 BTIF_TRACE_DEBUG("btif_hl_proc_create_ind:BTA_HL_MDEP_ROLE_SINK");
2616 if ((p_data->dch_create_ind.cfg == BTA_HL_DCH_CFG_RELIABLE) ||
2617 (first_reliable_exist && (p_data->dch_create_ind.cfg == BTA_HL_DCH_CFG_STREAMING)))
2618 {
2619 rsp_code = BTA_HL_DCH_CREATE_RSP_SUCCESS;
2620 rsp_cfg = p_data->dch_create_ind.cfg;
2621 BTIF_TRACE_DEBUG("btif_hl_proc_create_ind:BTA_HL_MDEP_ROLE_SINK cfg = %d",rsp_cfg);
2622 }
2623 break;
2624 default:
2625 break;
2626 }
2627 }
2628 }
2629 else
2630 {
2631 success = FALSE;
2632 }
2633
2634 if (success)
2635 {
2636 BTIF_TRACE_DEBUG("create response rsp_code=%d rsp_cfg=%d", rsp_code, rsp_cfg );
2637 create_rsp_param.local_mdep_id = p_data->dch_create_ind.local_mdep_id;
2638 create_rsp_param.mdl_id = p_data->dch_create_ind.mdl_id;
2639 create_rsp_param.rsp_code = rsp_code;
2640 create_rsp_param.cfg_rsp = rsp_cfg;
2641 BTA_HlDchCreateRsp(p_mcb->mcl_handle, &create_rsp_param);
2642 }
2643 }
2644
2645 /*******************************************************************************
2646 **
2647 ** Function btif_hl_proc_dch_open_ind
2648 **
2649 ** Description Process the DCH open indication
2650 **
2651 ** Returns Nothing
2652 **
2653 *******************************************************************************/
btif_hl_proc_dch_open_ind(tBTA_HL * p_data)2654 static void btif_hl_proc_dch_open_ind(tBTA_HL *p_data)
2655
2656 {
2657 btif_hl_mdl_cb_t *p_dcb;
2658 UINT8 orig_app_idx, mcl_idx, mdl_idx, mdep_cfg_idx;
2659 BOOLEAN close_dch = FALSE;
2660
2661 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2662
2663 // Find the correct app_idx based on the mdep_id;
2664 btif_hl_find_app_idx_using_mdepId(p_data->dch_open_ind.local_mdep_id,&orig_app_idx);
2665
2666 if (btif_hl_find_mcl_idx_using_app_idx(p_data->dch_open_ind.mcl_handle, orig_app_idx, &mcl_idx ))
2667 {
2668 if (btif_hl_find_avail_mdl_idx(orig_app_idx, mcl_idx, &mdl_idx))
2669 {
2670 p_dcb = BTIF_HL_GET_MDL_CB_PTR(orig_app_idx, mcl_idx, mdl_idx);
2671
2672 if (btif_hl_find_mdep_cfg_idx(orig_app_idx, p_data->dch_open_ind.local_mdep_id, &mdep_cfg_idx))
2673 {
2674 p_dcb->in_use = TRUE;
2675 p_dcb->mdl_handle = p_data->dch_open_ind.mdl_handle;
2676 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx;
2677 p_dcb->local_mdep_id = p_data->dch_open_ind.local_mdep_id;
2678 p_dcb->mdl_id = p_data->dch_open_ind.mdl_id;
2679 p_dcb->dch_mode = p_data->dch_open_ind.dch_mode;
2680 p_dcb->dch_mode = p_data->dch_open_ind.dch_mode;
2681 p_dcb->is_the_first_reliable = p_data->dch_open_ind.first_reliable;
2682 p_dcb->mtu = p_data->dch_open_ind.mtu;
2683
2684 if(btif_hl_find_channel_id_using_mdl_id(orig_app_idx,p_dcb->mdl_id , &p_dcb->channel_id))
2685 {
2686 BTIF_TRACE_DEBUG(" app_idx=%d mcl_idx=%d mdl_idx=%d channel_id=%d",
2687 orig_app_idx, mcl_idx, mdl_idx, p_dcb->channel_id );
2688 if (!btif_hl_create_socket(orig_app_idx, mcl_idx, mdl_idx))
2689 {
2690 BTIF_TRACE_ERROR("Unable to create socket");
2691 close_dch = TRUE;
2692 }
2693 }
2694 else
2695 {
2696 BTIF_TRACE_ERROR("Unable find channel id for mdl_id=0x%x", p_dcb->mdl_id );
2697 close_dch = TRUE;
2698 }
2699 }
2700 else
2701 {
2702 BTIF_TRACE_ERROR("INVALID_LOCAL_MDEP_ID mdep_id=%d",p_data->dch_open_cfm.local_mdep_id);
2703 close_dch = TRUE;
2704 }
2705
2706 if (close_dch)
2707 btif_hl_clean_mdl_cb(p_dcb);
2708 }
2709 else
2710 close_dch = TRUE;
2711 }
2712 else
2713 close_dch = TRUE;
2714
2715 if (close_dch)
2716 BTA_HlDchClose(p_data->dch_open_cfm.mdl_handle);
2717 }
2718
2719 /*******************************************************************************
2720 **
2721 ** Function btif_hl_proc_dch_open_cfm
2722 **
2723 ** Description Process the DCH close confirmation
2724 **
2725 ** Returns Nothing
2726 **
2727 *******************************************************************************/
btif_hl_proc_dch_open_cfm(tBTA_HL * p_data)2728 static BOOLEAN btif_hl_proc_dch_open_cfm(tBTA_HL *p_data)
2729
2730 {
2731 btif_hl_mdl_cb_t *p_dcb;
2732 btif_hl_pending_chan_cb_t *p_pcb;
2733 UINT8 app_idx, mcl_idx, mdl_idx, mdep_cfg_idx;
2734 BOOLEAN status = FALSE;
2735 BOOLEAN close_dch = FALSE;
2736
2737 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2738
2739 // Find the correct app_idx based on the mdep_id;
2740 btif_hl_find_app_idx_using_mdepId(p_data->dch_open_cfm.local_mdep_id,&app_idx);
2741
2742 if (btif_hl_find_mcl_idx_using_app_idx(p_data->dch_open_cfm.mcl_handle, app_idx, &mcl_idx ))
2743 {
2744 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
2745
2746 if (btif_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx))
2747 {
2748 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2749
2750 if (btif_hl_find_mdep_cfg_idx(app_idx, p_data->dch_open_cfm.local_mdep_id, &mdep_cfg_idx))
2751 {
2752 p_dcb->in_use = TRUE;
2753 p_dcb->mdl_handle = p_data->dch_open_cfm.mdl_handle;
2754 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx;
2755 p_dcb->local_mdep_id = p_data->dch_open_cfm.local_mdep_id;
2756 p_dcb->mdl_id = p_data->dch_open_cfm.mdl_id;
2757 p_dcb->dch_mode = p_data->dch_open_cfm.dch_mode;
2758 p_dcb->is_the_first_reliable= p_data->dch_open_cfm.first_reliable;
2759 p_dcb->mtu = p_data->dch_open_cfm.mtu;
2760 p_dcb->channel_id = p_pcb->channel_id;
2761
2762 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d mdl_idx=%d", app_idx, mcl_idx, mdl_idx );
2763 btif_hl_send_setup_connecting_cb(app_idx, mcl_idx);
2764 if (btif_hl_create_socket(app_idx, mcl_idx, mdl_idx))
2765 {
2766 status = TRUE;
2767 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d mdl_idx=%d p_dcb->channel_id=0x%08x",
2768 app_idx, mcl_idx, mdl_idx, p_dcb->channel_id);
2769 btif_hl_clean_pcb(p_pcb);
2770 }
2771 else
2772 {
2773 BTIF_TRACE_ERROR("Unable to create socket");
2774 close_dch = TRUE;
2775 }
2776 }
2777 else
2778 {
2779 BTIF_TRACE_ERROR("INVALID_LOCAL_MDEP_ID mdep_id=%d",p_data->dch_open_cfm.local_mdep_id);
2780 close_dch = TRUE;
2781 }
2782
2783 if (close_dch)
2784 {
2785 btif_hl_clean_mdl_cb(p_dcb);
2786 BTA_HlDchClose(p_data->dch_open_cfm.mdl_handle);
2787 }
2788 }
2789 }
2790
2791 return status;
2792 }
2793 /*******************************************************************************
2794 **
2795 ** Function btif_hl_proc_dch_reconnect_cfm
2796 **
2797 ** Description Process the DCH reconnect indication
2798 **
2799 ** Returns Nothing
2800 **
2801 *******************************************************************************/
btif_hl_proc_dch_reconnect_cfm(tBTA_HL * p_data)2802 static BOOLEAN btif_hl_proc_dch_reconnect_cfm(tBTA_HL *p_data)
2803 {
2804 btif_hl_mdl_cb_t *p_dcb;
2805 btif_hl_pending_chan_cb_t *p_pcb;
2806 UINT8 app_idx, mcl_idx, mdl_idx, mdep_cfg_idx;
2807 BOOLEAN status = FALSE;
2808 BOOLEAN close_dch = FALSE;
2809
2810 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2811
2812 btif_hl_find_app_idx_using_mdepId(p_data->dch_reconnect_cfm.local_mdep_id,&app_idx);
2813
2814 if (btif_hl_find_mcl_idx_using_app_idx(p_data->dch_reconnect_cfm.mcl_handle, app_idx, &mcl_idx ))
2815 {
2816 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
2817
2818 if (btif_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx))
2819 {
2820 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2821
2822 if (btif_hl_find_mdep_cfg_idx(app_idx, p_data->dch_reconnect_cfm.local_mdep_id, &mdep_cfg_idx))
2823 {
2824 p_dcb->in_use = TRUE;
2825 p_dcb->mdl_handle = p_data->dch_reconnect_cfm.mdl_handle;
2826 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx;
2827 p_dcb->local_mdep_id = p_data->dch_reconnect_cfm.local_mdep_id;
2828 p_dcb->mdl_id = p_data->dch_reconnect_cfm.mdl_id;
2829 p_dcb->dch_mode = p_data->dch_reconnect_cfm.dch_mode;
2830 p_dcb->is_the_first_reliable= p_data->dch_reconnect_cfm.first_reliable;
2831 p_dcb->mtu = p_data->dch_reconnect_cfm.mtu;
2832 p_dcb->channel_id = p_pcb->channel_id;
2833
2834 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d mdl_idx=%d", app_idx, mcl_idx, mdl_idx );
2835 btif_hl_send_setup_connecting_cb(app_idx, mcl_idx);
2836 if (btif_hl_create_socket(app_idx, mcl_idx, mdl_idx))
2837 {
2838 status = TRUE;
2839 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d mdl_idx=%d p_dcb->channel_id=0x%08x",
2840 app_idx, mcl_idx, mdl_idx, p_dcb->channel_id);
2841 btif_hl_clean_pcb(p_pcb);
2842 }
2843 else
2844 {
2845 BTIF_TRACE_ERROR("Unable to create socket");
2846 close_dch = TRUE;
2847 }
2848 }
2849 else
2850 {
2851 BTIF_TRACE_ERROR("INVALID_LOCAL_MDEP_ID mdep_id=%d",p_data->dch_open_cfm.local_mdep_id);
2852 close_dch = TRUE;
2853 }
2854
2855 if (close_dch)
2856 {
2857 btif_hl_clean_mdl_cb(p_dcb);
2858 BTA_HlDchClose(p_data->dch_reconnect_cfm.mdl_handle);
2859 }
2860 }
2861 }
2862
2863 return status;
2864
2865 }
2866 /*******************************************************************************
2867 **
2868 ** Function btif_hl_proc_dch_reconnect_ind
2869 **
2870 ** Description Process the DCH reconnect indication
2871 **
2872 ** Returns Nothing
2873 **
2874 *******************************************************************************/
btif_hl_proc_dch_reconnect_ind(tBTA_HL * p_data)2875 static void btif_hl_proc_dch_reconnect_ind(tBTA_HL *p_data)
2876
2877 {
2878 btif_hl_app_cb_t *p_acb;
2879 btif_hl_mdl_cb_t *p_dcb;
2880 UINT8 app_idx, mcl_idx, mdl_idx, mdep_cfg_idx;
2881 BOOLEAN close_dch = FALSE;
2882
2883 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2884
2885 // Find the correct app_idx based on the mdep_id;
2886 btif_hl_find_app_idx_using_mdepId(p_data->dch_reconnect_ind.local_mdep_id,&app_idx);
2887
2888 if (btif_hl_find_mcl_idx_using_app_idx(p_data->dch_reconnect_ind.mcl_handle, app_idx, &mcl_idx ))
2889 {
2890 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
2891 BTIF_TRACE_DEBUG("btif_hl_proc_dch_reconnect_ind: app_idx = %d, mcl_idx = %d",
2892 app_idx, mcl_idx);
2893
2894 if (btif_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx))
2895 {
2896 p_dcb =BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2897
2898 if (btif_hl_find_mdep_cfg_idx(app_idx, p_data->dch_reconnect_ind.local_mdep_id, &mdep_cfg_idx))
2899 {
2900 p_dcb->in_use = TRUE;
2901 p_dcb->mdl_handle = p_data->dch_reconnect_ind.mdl_handle;
2902 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx;
2903 p_dcb->local_mdep_id = p_data->dch_reconnect_ind.local_mdep_id;
2904 p_dcb->mdl_id = p_data->dch_reconnect_ind.mdl_id;
2905 p_dcb->dch_mode = p_data->dch_reconnect_ind.dch_mode;
2906 p_dcb->dch_mode = p_data->dch_reconnect_ind.dch_mode;
2907 p_dcb->is_the_first_reliable= p_data->dch_reconnect_ind.first_reliable;
2908 p_dcb->mtu = p_data->dch_reconnect_ind.mtu;
2909 p_dcb->channel_id = btif_hl_get_next_channel_id(p_acb->app_id);
2910
2911 BTIF_TRACE_DEBUG(" app_idx=%d mcl_idx=%d mdl_idx=%d channel_id=%d",
2912 app_idx, mcl_idx, mdl_idx, p_dcb->channel_id );
2913 if (!btif_hl_create_socket(app_idx, mcl_idx, mdl_idx))
2914 {
2915 BTIF_TRACE_ERROR("Unable to create socket");
2916 close_dch = TRUE;
2917 }
2918 }
2919 else
2920 {
2921 BTIF_TRACE_ERROR("INVALID_LOCAL_MDEP_ID mdep_id=%d",p_data->dch_open_cfm.local_mdep_id);
2922 close_dch = TRUE;
2923 }
2924
2925 if (close_dch)
2926 btif_hl_clean_mdl_cb(p_dcb);
2927 }
2928 else
2929 close_dch = TRUE;
2930 }
2931 else
2932 close_dch = TRUE;
2933
2934 if (close_dch)
2935 BTA_HlDchClose(p_data->dch_reconnect_ind.mdl_handle);
2936
2937 }
2938
2939 /*******************************************************************************
2940 **
2941 ** Function btif_hl_proc_dch_close_ind
2942 **
2943 ** Description Process the DCH close indication
2944 **
2945 ** Returns Nothing
2946 **
2947 *******************************************************************************/
btif_hl_proc_dch_close_ind(tBTA_HL * p_data)2948 static void btif_hl_proc_dch_close_ind(tBTA_HL *p_data)
2949
2950 {
2951 btif_hl_mdl_cb_t *p_dcb;
2952 btif_hl_mcl_cb_t *p_mcb;
2953 UINT8 app_idx, mcl_idx, mdl_idx;
2954
2955 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2956 if (btif_hl_find_mdl_idx_using_handle(p_data->dch_close_ind.mdl_handle,
2957 &app_idx, &mcl_idx, &mdl_idx ))
2958 {
2959 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2960 btif_hl_release_socket(app_idx,mcl_idx, mdl_idx);
2961 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx);
2962 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx,mcl_idx);
2963 btif_hl_clean_mdl_cb(p_dcb);
2964 if (!btif_hl_num_dchs_in_use(p_mcb->mcl_handle))
2965 btif_hl_start_cch_timer(app_idx, mcl_idx);
2966 BTIF_TRACE_DEBUG("remote DCH close success mdl_idx=%d", mdl_idx);
2967 }
2968 }
2969
2970 /*******************************************************************************
2971 **
2972 ** Function btif_hl_proc_dch_close_cfm
2973 **
2974 ** Description Process the DCH reconnect confirmation
2975 **
2976 ** Returns Nothing
2977 **
2978 *******************************************************************************/
btif_hl_proc_dch_close_cfm(tBTA_HL * p_data)2979 static void btif_hl_proc_dch_close_cfm(tBTA_HL *p_data)
2980
2981 {
2982 btif_hl_mdl_cb_t *p_dcb;
2983 btif_hl_mcl_cb_t *p_mcb;
2984 UINT8 app_idx, mcl_idx, mdl_idx;
2985
2986 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2987 if (btif_hl_find_mdl_idx_using_handle(p_data->dch_close_cfm.mdl_handle,
2988 &app_idx, &mcl_idx, &mdl_idx ))
2989 {
2990 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2991 btif_hl_release_socket(app_idx,mcl_idx,mdl_idx);
2992 btif_hl_clean_mdl_cb(p_dcb);
2993 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx,mcl_idx);
2994 if (!btif_hl_num_dchs_in_use(p_mcb->mcl_handle))
2995 btif_hl_start_cch_timer(app_idx, mcl_idx);
2996 BTIF_TRACE_DEBUG(" local DCH close success mdl_idx=%d", mdl_idx);
2997 }
2998 }
2999
3000 /*******************************************************************************
3001 **
3002 ** Function btif_hl_proc_abort_ind
3003 **
3004 ** Description Process the abort indicaiton
3005 **
3006 ** Returns Nothing
3007 **
3008 *******************************************************************************/
btif_hl_proc_abort_ind(tBTA_HL_MCL_HANDLE mcl_handle)3009 static void btif_hl_proc_abort_ind(tBTA_HL_MCL_HANDLE mcl_handle){
3010
3011 BTIF_TRACE_DEBUG("%s", __FUNCTION__ );
3012 btif_hl_app_cb_t *p_acb;
3013 UINT8 i,j;
3014
3015 for (i=0; i<BTA_HL_NUM_APPS; i++)
3016 {
3017 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
3018 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
3019 {
3020 if (p_acb->mcb[j].in_use)
3021 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);
3022 if (p_acb->mcb[j].in_use &&
3023 (p_acb->mcb[j].mcl_handle == mcl_handle))
3024 {
3025 btif_hl_stop_cch_timer(i, j);
3026 btif_hl_send_setup_disconnected_cb(i, j);
3027 btif_hl_clean_mcl_cb(i, j);
3028 }
3029 }
3030 }
3031 }
3032
3033 /*******************************************************************************
3034 **
3035 ** Function btif_hl_proc_abort_cfm
3036 **
3037 ** Description Process the abort confirmation
3038 **
3039 ** Returns Nothing
3040 **
3041 *******************************************************************************/
btif_hl_proc_abort_cfm(tBTA_HL_MCL_HANDLE mcl_handle)3042 static void btif_hl_proc_abort_cfm(tBTA_HL_MCL_HANDLE mcl_handle){
3043 BTIF_TRACE_DEBUG("%s", __FUNCTION__ );
3044 btif_hl_app_cb_t *p_acb;
3045 UINT8 i,j;
3046
3047 for (i=0; i<BTA_HL_NUM_APPS; i++)
3048 {
3049 p_acb =BTIF_HL_GET_APP_CB_PTR(i);
3050 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
3051 {
3052 if (p_acb->mcb[j].in_use)
3053 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);
3054 if (p_acb->mcb[j].in_use &&
3055 (p_acb->mcb[j].mcl_handle == mcl_handle))
3056 {
3057 btif_hl_stop_cch_timer(i, j);
3058 btif_hl_send_setup_disconnected_cb(i, j);
3059 btif_hl_clean_mcl_cb(i, j);
3060 }
3061 }
3062 }
3063
3064 }
3065
3066 /*******************************************************************************
3067 **
3068 ** Function btif_hl_proc_send_data_cfm
3069 **
3070 ** Description Process the send data confirmation
3071 **
3072 ** Returns Nothing
3073 **
3074 *******************************************************************************/
btif_hl_proc_send_data_cfm(tBTA_HL_MDL_HANDLE mdl_handle,tBTA_HL_STATUS status)3075 static void btif_hl_proc_send_data_cfm(tBTA_HL_MDL_HANDLE mdl_handle,
3076 tBTA_HL_STATUS status){
3077 UINT8 app_idx,mcl_idx, mdl_idx;
3078 btif_hl_mdl_cb_t *p_dcb;
3079 UNUSED(status);
3080
3081 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
3082 if (btif_hl_find_mdl_idx_using_handle(mdl_handle,
3083 &app_idx, &mcl_idx, &mdl_idx ))
3084 {
3085 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
3086 osi_free_and_reset((void **)&p_dcb->p_tx_pkt);
3087 BTIF_TRACE_DEBUG("send success free p_tx_pkt tx_size=%d",
3088 p_dcb->tx_size);
3089 p_dcb->tx_size = 0;
3090 }
3091 }
3092
3093 /*******************************************************************************
3094 **
3095 ** Function btif_hl_proc_dch_cong_ind
3096 **
3097 ** Description Process the DCH congestion change indication
3098 **
3099 ** Returns Nothing
3100 **
3101 *******************************************************************************/
btif_hl_proc_dch_cong_ind(tBTA_HL * p_data)3102 static void btif_hl_proc_dch_cong_ind(tBTA_HL *p_data)
3103
3104 {
3105 btif_hl_mdl_cb_t *p_dcb;
3106 UINT8 app_idx, mcl_idx, mdl_idx;
3107
3108 BTIF_TRACE_DEBUG("btif_hl_proc_dch_cong_ind");
3109
3110 if (btif_hl_find_mdl_idx_using_handle(p_data->dch_cong_ind.mdl_handle, &app_idx, &mcl_idx, &mdl_idx))
3111 {
3112 p_dcb =BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
3113 p_dcb->cong = p_data->dch_cong_ind.cong;
3114 }
3115 }
3116
3117 /*******************************************************************************
3118 **
3119 ** Function btif_hl_proc_reg_request
3120 **
3121 ** Description Process registration request
3122 **
3123 ** Returns void
3124 **
3125 *******************************************************************************/
btif_hl_proc_reg_request(UINT8 app_idx,UINT8 app_id,tBTA_HL_REG_PARAM * p_reg_param,tBTA_HL_CBACK * p_cback)3126 static void btif_hl_proc_reg_request(UINT8 app_idx, UINT8 app_id,
3127 tBTA_HL_REG_PARAM *p_reg_param,
3128 tBTA_HL_CBACK *p_cback){
3129 UNUSED(p_cback);
3130
3131 BTIF_TRACE_DEBUG("%s app_idx=%d app_id=%d", __FUNCTION__, app_idx, app_id);
3132
3133 if(reg_counter >1)
3134 {
3135 BTIF_TRACE_DEBUG("btif_hl_proc_reg_request: calling uPDATE");
3136 BTA_HlUpdate(app_id, p_reg_param,TRUE, btif_hl_cback);
3137 }
3138 else
3139 BTA_HlRegister(app_id, p_reg_param, btif_hl_cback);
3140 }
3141
3142 /*******************************************************************************
3143 **
3144 ** Function btif_hl_proc_cb_evt
3145 **
3146 ** Description Process HL callback events
3147 **
3148 ** Returns void
3149 **
3150 *******************************************************************************/
btif_hl_proc_cb_evt(UINT16 event,char * p_param)3151 static void btif_hl_proc_cb_evt(UINT16 event, char* p_param){
3152
3153 btif_hl_evt_cb_t *p_data = (btif_hl_evt_cb_t *)p_param;
3154 bt_bdaddr_t bd_addr;
3155 bthl_channel_state_t state=BTHL_CONN_STATE_DISCONNECTED;
3156 BOOLEAN send_chan_cb=TRUE;
3157 tBTA_HL_REG_PARAM reg_param;
3158 btif_hl_app_cb_t *p_acb;
3159
3160 BTIF_TRACE_DEBUG("%s event %d", __FUNCTION__, event);
3161 btif_hl_display_calling_process_name();
3162
3163 switch (event)
3164 {
3165 case BTIF_HL_SEND_CONNECTED_CB:
3166 case BTIF_HL_SEND_DISCONNECTED_CB:
3167 if (p_data->chan_cb.cb_state == BTIF_HL_CHAN_CB_STATE_CONNECTED_PENDING)
3168 state = BTHL_CONN_STATE_CONNECTED;
3169 else if (p_data->chan_cb.cb_state == BTIF_HL_CHAN_CB_STATE_DISCONNECTED_PENDING)
3170 state = BTHL_CONN_STATE_DISCONNECTED;
3171 else
3172 send_chan_cb = FALSE;
3173
3174 if (send_chan_cb)
3175 {
3176 btif_hl_copy_bda(&bd_addr, p_data->chan_cb.bd_addr);
3177 BTIF_TRACE_DEBUG("state callbk: ch_id=0x%08x cb_state=%d state=%d fd=%d",
3178 p_data->chan_cb.channel_id,
3179 p_data->chan_cb.cb_state,
3180 state, p_data->chan_cb.fd);
3181 btif_hl_display_bt_bda(&bd_addr);
3182 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, p_data->chan_cb.app_id,
3183 &bd_addr, p_data->chan_cb.mdep_cfg_index,
3184 p_data->chan_cb.channel_id, state, p_data->chan_cb.fd );
3185 }
3186
3187 break;
3188 case BTIF_HL_REG_APP:
3189 p_acb = BTIF_HL_GET_APP_CB_PTR(p_data->reg.app_idx);
3190 BTIF_TRACE_DEBUG("Rcv BTIF_HL_REG_APP app_idx=%d reg_pending=%d", p_data->reg.app_idx, p_acb->reg_pending);
3191 if (btif_hl_get_state() == BTIF_HL_STATE_ENABLED && p_acb->reg_pending)
3192 {
3193 BTIF_TRACE_DEBUG("Rcv BTIF_HL_REG_APP reg_counter=%d",reg_counter);
3194 p_acb->reg_pending = FALSE;
3195 reg_param.dev_type = p_acb->dev_type;
3196 reg_param.sec_mask = BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT;
3197 reg_param.p_srv_name = p_acb->srv_name;
3198 reg_param.p_srv_desp = p_acb->srv_desp;
3199 reg_param.p_provider_name = p_acb->provider_name;
3200 btif_hl_proc_reg_request (p_data->reg.app_idx, p_acb->app_id, ®_param, btif_hl_cback);
3201 }
3202 else
3203 {
3204 BTIF_TRACE_DEBUG("reg request is processed state=%d reg_pending=%d", btif_hl_get_state(), p_acb->reg_pending);
3205 }
3206
3207 break;
3208
3209 case BTIF_HL_UNREG_APP:
3210 BTIF_TRACE_DEBUG("Rcv BTIF_HL_UNREG_APP app_idx=%d", p_data->unreg.app_idx );
3211 p_acb = BTIF_HL_GET_APP_CB_PTR(p_data->unreg.app_idx);
3212 if (btif_hl_get_state() == BTIF_HL_STATE_ENABLED)
3213 {
3214 if(reg_counter >= 1)
3215 BTA_HlUpdate(p_acb->app_id,NULL,FALSE,NULL);
3216 else
3217 BTA_HlDeregister(p_acb->app_id, p_acb->app_handle);
3218 }
3219 break;
3220 case BTIF_HL_UPDATE_MDL:
3221 BTIF_TRACE_DEBUG("Rcv BTIF_HL_UPDATE_MDL app_idx=%d", p_data->update_mdl.app_idx );
3222 p_acb = BTIF_HL_GET_APP_CB_PTR(p_data->update_mdl.app_idx);
3223 break;
3224
3225 default:
3226 BTIF_TRACE_ERROR("Unknown event %d", event);
3227 break;
3228 }
3229 }
3230
3231 /*******************************************************************************
3232 **
3233 ** Function btif_hl_upstreams_evt
3234 **
3235 ** Description Process HL events
3236 **
3237 ** Returns void
3238 **
3239 *******************************************************************************/
btif_hl_upstreams_evt(UINT16 event,char * p_param)3240 static void btif_hl_upstreams_evt(UINT16 event, char* p_param){
3241 tBTA_HL *p_data = (tBTA_HL *)p_param;
3242 UINT8 app_idx, mcl_idx;
3243 btif_hl_app_cb_t *p_acb;
3244 btif_hl_mcl_cb_t *p_mcb = NULL;
3245 btif_hl_pend_dch_op_t pending_op;
3246 BOOLEAN status;
3247
3248 BTIF_TRACE_DEBUG("%s event %d", __FUNCTION__, event);
3249 btif_hl_display_calling_process_name();
3250 switch (event)
3251 {
3252 case BTA_HL_REGISTER_CFM_EVT:
3253 BTIF_TRACE_DEBUG("Rcv BTA_HL_REGISTER_CFM_EVT");
3254 BTIF_TRACE_DEBUG("app_id=%d app_handle=%d status=%d ",
3255 p_data->reg_cfm.app_id,
3256 p_data->reg_cfm.app_handle,
3257 p_data->reg_cfm.status );
3258
3259 btif_hl_proc_reg_cfm(p_data);
3260 break;
3261 case BTA_HL_SDP_INFO_IND_EVT:
3262 BTIF_TRACE_DEBUG("Rcv BTA_HL_SDP_INFO_IND_EVT");
3263 BTIF_TRACE_DEBUG("app_handle=%d ctrl_psm=0x%04x data_psm=0x%04x x_spec=%d mcap_sup_procs=0x%02x",
3264 p_data->sdp_info_ind.app_handle,
3265 p_data->sdp_info_ind.ctrl_psm,
3266 p_data->sdp_info_ind.data_psm,
3267 p_data->sdp_info_ind.data_x_spec,
3268 p_data->sdp_info_ind.mcap_sup_procs);
3269 //btif_hl_proc_sdp_info_ind(p_data);
3270 break;
3271
3272 case BTA_HL_DEREGISTER_CFM_EVT:
3273 BTIF_TRACE_DEBUG("Rcv BTA_HL_DEREGISTER_CFM_EVT");
3274 BTIF_TRACE_DEBUG("app_handle=%d status=%d ",
3275 p_data->dereg_cfm.app_handle,
3276 p_data->dereg_cfm.status );
3277 btif_hl_proc_dereg_cfm(p_data);
3278 break;
3279
3280 case BTA_HL_SDP_QUERY_CFM_EVT:
3281 BTIF_TRACE_DEBUG("Rcv BTA_HL_SDP_QUERY_CFM_EVT");
3282 BTIF_TRACE_DEBUG("app_handle=%d app_id =%d,status =%d",
3283 p_data->sdp_query_cfm.app_handle,p_data->sdp_query_cfm.app_id,
3284 p_data->sdp_query_cfm.status);
3285
3286 BTIF_TRACE_DEBUG("DB [%02x] [%02x] [%02x] [%02x] [%02x] [%02x]",
3287 p_data->sdp_query_cfm.bd_addr[0], p_data->sdp_query_cfm.bd_addr[1],
3288 p_data->sdp_query_cfm.bd_addr[2], p_data->sdp_query_cfm.bd_addr[3],
3289 p_data->sdp_query_cfm.bd_addr[4], p_data->sdp_query_cfm.bd_addr[5]);
3290
3291 if (p_data->sdp_query_cfm.status == BTA_HL_STATUS_OK)
3292 status = btif_hl_proc_sdp_query_cfm(p_data);
3293 else
3294 status = FALSE;
3295
3296 if (!status)
3297 {
3298 BTIF_TRACE_DEBUG("BTA_HL_SDP_QUERY_CFM_EVT Status = %d",
3299 p_data->sdp_query_cfm.status);
3300 if (btif_hl_find_app_idx_using_app_id(p_data->sdp_query_cfm.app_id, &app_idx))
3301 {
3302 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
3303 if (btif_hl_find_mcl_idx(app_idx, p_data->sdp_query_cfm.bd_addr, &mcl_idx))
3304 {
3305 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
3306 if ( (p_mcb->cch_oper == BTIF_HL_CCH_OP_MDEP_FILTERING) ||
3307 (p_mcb->cch_oper == BTIF_HL_CCH_OP_DCH_OPEN) )
3308 {
3309 pending_op = p_mcb->pcb.op;
3310 switch (pending_op)
3311 {
3312 case BTIF_HL_PEND_DCH_OP_OPEN:
3313 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx);
3314 break;
3315 case BTIF_HL_PEND_DCH_OP_RECONNECT:
3316 case BTIF_HL_PEND_DCH_OP_DELETE_MDL:
3317 default:
3318 break;
3319 }
3320 if (!p_mcb->is_connected)
3321 btif_hl_clean_mcl_cb(app_idx, mcl_idx);
3322 }
3323 }
3324 }
3325 }
3326
3327 break;
3328
3329 case BTA_HL_CCH_OPEN_CFM_EVT:
3330 BTIF_TRACE_DEBUG("Rcv BTA_HL_CCH_OPEN_CFM_EVT");
3331 BTIF_TRACE_DEBUG("app_id=%d,app_handle=%d mcl_handle=%d status =%d",
3332 p_data->cch_open_cfm.app_id,
3333 p_data->cch_open_cfm.app_handle,
3334 p_data->cch_open_cfm.mcl_handle,
3335 p_data->cch_open_cfm.status);
3336 BTIF_TRACE_DEBUG("DB [%02x] [%02x] [%02x] [%02x] [%02x] [%02x]",
3337 p_data->cch_open_cfm.bd_addr[0], p_data->cch_open_cfm.bd_addr[1],
3338 p_data->cch_open_cfm.bd_addr[2], p_data->cch_open_cfm.bd_addr[3],
3339 p_data->cch_open_cfm.bd_addr[4], p_data->cch_open_cfm.bd_addr[5]);
3340
3341 if (p_data->cch_open_cfm.status == BTA_HL_STATUS_OK ||
3342 p_data->cch_open_cfm.status == BTA_HL_STATUS_DUPLICATE_CCH_OPEN)
3343 {
3344 status = btif_hl_proc_cch_open_cfm(p_data);
3345 }
3346 else
3347 {
3348 status = FALSE;
3349 }
3350
3351 if (!status)
3352 {
3353 if (btif_hl_find_app_idx_using_app_id(p_data->cch_open_cfm.app_id, &app_idx))
3354 {
3355 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
3356 if (btif_hl_find_mcl_idx(app_idx, p_data->cch_open_cfm.bd_addr, &mcl_idx))
3357 {
3358 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
3359 pending_op = p_mcb->pcb.op;
3360 switch (pending_op)
3361 {
3362 case BTIF_HL_PEND_DCH_OP_OPEN:
3363 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx);
3364 break;
3365 case BTIF_HL_PEND_DCH_OP_RECONNECT:
3366 case BTIF_HL_PEND_DCH_OP_DELETE_MDL:
3367 default:
3368 break;
3369 }
3370 btif_hl_clean_mcl_cb(app_idx, mcl_idx);
3371 }
3372 }
3373 }
3374 break;
3375
3376 case BTA_HL_DCH_OPEN_CFM_EVT:
3377 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_OPEN_CFM_EVT");
3378 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_handle=0x%x status=%d ",
3379 p_data->dch_open_cfm.mcl_handle,
3380 p_data->dch_open_cfm.mdl_handle,
3381 p_data->dch_open_cfm.status);
3382 BTIF_TRACE_DEBUG("first_reliable =%d dch_mode=%d local_mdep_id=%d mdl_id=%d mtu=%d",
3383 p_data->dch_open_cfm.first_reliable,
3384 p_data->dch_open_cfm.dch_mode,
3385 p_data->dch_open_cfm.local_mdep_id,
3386 p_data->dch_open_cfm.mdl_id,
3387 p_data->dch_open_cfm.mtu);
3388 if (p_data->dch_open_cfm.status == BTA_HL_STATUS_OK)
3389 {
3390 status = btif_hl_proc_dch_open_cfm(p_data);
3391 }
3392 else
3393 {
3394 status = FALSE;
3395 }
3396
3397 if (!status)
3398 {
3399 if (btif_hl_find_mcl_idx_using_handle(p_data->dch_open_cfm.mcl_handle,&app_idx, &mcl_idx))
3400 {
3401 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
3402 pending_op = p_mcb->pcb.op;
3403 switch (pending_op)
3404 {
3405 case BTIF_HL_PEND_DCH_OP_OPEN:
3406 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx);
3407 break;
3408 case BTIF_HL_PEND_DCH_OP_RECONNECT:
3409 case BTIF_HL_PEND_DCH_OP_DELETE_MDL:
3410 default:
3411 break;
3412 }
3413 }
3414 }
3415 break;
3416
3417 case BTA_HL_CCH_OPEN_IND_EVT:
3418 BTIF_TRACE_DEBUG("Rcv BTA_HL_CCH_OPEN_IND_EVT");
3419 BTIF_TRACE_DEBUG("app_handle=%d mcl_handle=%d",
3420 p_data->cch_open_ind.app_handle,
3421 p_data->cch_open_ind.mcl_handle);
3422 BTIF_TRACE_DEBUG("DB [%02x] [%02x] [%02x] [%02x] [%02x] [%02x]",
3423 p_data->cch_open_ind.bd_addr[0], p_data->cch_open_ind.bd_addr[1],
3424 p_data->cch_open_ind.bd_addr[2], p_data->cch_open_ind.bd_addr[3],
3425 p_data->cch_open_ind.bd_addr[4], p_data->cch_open_ind.bd_addr[5]);
3426
3427 btif_hl_proc_cch_open_ind(p_data);
3428 break;
3429
3430 case BTA_HL_DCH_CREATE_IND_EVT:
3431 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_CREATE_IND_EVT");
3432 BTIF_TRACE_DEBUG("mcl_handle=%d",
3433 p_data->dch_create_ind.mcl_handle );
3434 BTIF_TRACE_DEBUG("local_mdep_id =%d mdl_id=%d cfg=%d",
3435 p_data->dch_create_ind.local_mdep_id,
3436 p_data->dch_create_ind.mdl_id,
3437 p_data->dch_create_ind.cfg);
3438 btif_hl_proc_create_ind(p_data);
3439 break;
3440
3441 case BTA_HL_DCH_OPEN_IND_EVT:
3442 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_OPEN_IND_EVT");
3443 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_handle=0x%x",
3444 p_data->dch_open_ind.mcl_handle,
3445 p_data->dch_open_ind.mdl_handle );
3446 BTIF_TRACE_DEBUG("first_reliable =%d dch_mode=%d local_mdep_id=%d mdl_id=%d mtu=%d",
3447 p_data->dch_open_ind.first_reliable,
3448 p_data->dch_open_ind.dch_mode,
3449 p_data->dch_open_ind.local_mdep_id,
3450 p_data->dch_open_ind.mdl_id,
3451 p_data->dch_open_ind.mtu);
3452
3453 btif_hl_proc_dch_open_ind(p_data);
3454 break;
3455
3456 case BTA_HL_DELETE_MDL_IND_EVT:
3457 BTIF_TRACE_DEBUG("Rcv BTA_HL_DELETE_MDL_IND_EVT");
3458 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_id=0x%x",
3459 p_data->delete_mdl_ind.mcl_handle,
3460 p_data->delete_mdl_ind.mdl_id);
3461 break;
3462
3463 case BTA_HL_DELETE_MDL_CFM_EVT:
3464 BTIF_TRACE_DEBUG("Rcv BTA_HL_DELETE_MDL_CFM_EVT");
3465 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_id=0x%x status=%d",
3466 p_data->delete_mdl_cfm.mcl_handle,
3467 p_data->delete_mdl_cfm.mdl_id,
3468 p_data->delete_mdl_cfm.status);
3469
3470 if (btif_hl_find_app_idx_using_deleted_mdl_id( p_data->delete_mdl_cfm.mdl_id,
3471 &app_idx))
3472 {
3473 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
3474 btif_hl_send_destroyed_cb(p_acb);
3475 btif_hl_clean_delete_mdl(&p_acb->delete_mdl);
3476 }
3477 break;
3478
3479 case BTA_HL_DCH_RECONNECT_CFM_EVT:
3480 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_RECONNECT_CFM_EVT");
3481 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_handle=%d status=%d ",
3482 p_data->dch_reconnect_cfm.mcl_handle,
3483 p_data->dch_reconnect_cfm.mdl_handle,
3484 p_data->dch_reconnect_cfm.status);
3485 BTIF_TRACE_DEBUG("first_reliable =%d dch_mode=%d mdl_id=%d mtu=%d",
3486 p_data->dch_reconnect_cfm.first_reliable,
3487 p_data->dch_reconnect_cfm.dch_mode,
3488 p_data->dch_reconnect_cfm.mdl_id,
3489 p_data->dch_reconnect_cfm.mtu);
3490
3491 if (p_data->dch_reconnect_cfm.status == BTA_HL_STATUS_OK)
3492 {
3493 status = btif_hl_proc_dch_reconnect_cfm(p_data);
3494 }
3495 else
3496 {
3497 status = FALSE;
3498 }
3499
3500 if (!status)
3501 {
3502 if (btif_hl_find_mcl_idx_using_handle(p_data->dch_open_cfm.mcl_handle,&app_idx, &mcl_idx))
3503 {
3504 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
3505 pending_op = p_mcb->pcb.op;
3506 switch (pending_op)
3507 {
3508 case BTIF_HL_PEND_DCH_OP_OPEN:
3509 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx);
3510 break;
3511 case BTIF_HL_PEND_DCH_OP_RECONNECT:
3512 case BTIF_HL_PEND_DCH_OP_DELETE_MDL:
3513 default:
3514 break;
3515 }
3516 }
3517 }
3518
3519 break;
3520
3521 case BTA_HL_CCH_CLOSE_CFM_EVT:
3522 BTIF_TRACE_DEBUG("Rcv BTA_HL_CCH_CLOSE_CFM_EVT");
3523 BTIF_TRACE_DEBUG("mcl_handle=%d status =%d",
3524 p_data->cch_close_cfm.mcl_handle,
3525 p_data->cch_close_cfm.status);
3526 if (p_data->cch_close_cfm.status == BTA_HL_STATUS_OK)
3527 {
3528 btif_hl_proc_cch_close_cfm(p_data);
3529 }
3530 break;
3531
3532 case BTA_HL_CCH_CLOSE_IND_EVT:
3533 BTIF_TRACE_DEBUG("Rcv BTA_HL_CCH_CLOSE_IND_EVT");
3534 BTIF_TRACE_DEBUG("mcl_handle =%d intentional_close=%s",
3535 p_data->cch_close_ind.mcl_handle,
3536 (p_data->cch_close_ind.intentional?"Yes":"No"));
3537
3538 btif_hl_proc_cch_close_ind(p_data);
3539 break;
3540
3541 case BTA_HL_DCH_CLOSE_IND_EVT:
3542 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_CLOSE_IND_EVT");
3543 BTIF_TRACE_DEBUG("mdl_handle=%d intentional_close=%s",
3544 p_data->dch_close_ind.mdl_handle,
3545 (p_data->dch_close_ind.intentional?"Yes":"No") );
3546
3547 btif_hl_proc_dch_close_ind(p_data);
3548 break;
3549
3550 case BTA_HL_DCH_CLOSE_CFM_EVT:
3551 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_CLOSE_CFM_EVT");
3552 BTIF_TRACE_DEBUG("mdl_handle=%d status=%d ",
3553 p_data->dch_close_cfm.mdl_handle,
3554 p_data->dch_close_cfm.status);
3555
3556 if (p_data->dch_close_cfm.status == BTA_HL_STATUS_OK)
3557 {
3558 btif_hl_proc_dch_close_cfm(p_data);
3559 }
3560 break;
3561
3562 case BTA_HL_DCH_ECHO_TEST_CFM_EVT:
3563 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_ECHO_TEST_CFM_EVT");
3564 BTIF_TRACE_DEBUG("mcl_handle=%d status=%d",
3565 p_data->echo_test_cfm.mcl_handle,
3566 p_data->echo_test_cfm.status );
3567 /* not supported */
3568 break;
3569
3570 case BTA_HL_DCH_RECONNECT_IND_EVT:
3571 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_RECONNECT_IND_EVT");
3572
3573 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_handle=5d",
3574 p_data->dch_reconnect_ind.mcl_handle,
3575 p_data->dch_reconnect_ind.mdl_handle );
3576 BTIF_TRACE_DEBUG("first_reliable =%d dch_mode=%d mdl_id=%d mtu=%d",
3577 p_data->dch_reconnect_ind.first_reliable,
3578 p_data->dch_reconnect_ind.dch_mode,
3579 p_data->dch_reconnect_ind.mdl_id,
3580 p_data->dch_reconnect_ind.mtu);
3581
3582 btif_hl_proc_dch_reconnect_ind(p_data);
3583 break;
3584
3585 case BTA_HL_CONG_CHG_IND_EVT:
3586 BTIF_TRACE_DEBUG("Rcv BTA_HL_CONG_CHG_IND_EVT");
3587 BTIF_TRACE_DEBUG("mdl_handle=%d cong =%d",
3588 p_data->dch_cong_ind.mdl_handle,
3589 p_data->dch_cong_ind.cong);
3590 btif_hl_proc_dch_cong_ind(p_data);
3591 break;
3592
3593 case BTA_HL_DCH_ABORT_IND_EVT:
3594 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_ABORT_IND_EVT");
3595 BTIF_TRACE_DEBUG("mcl_handle=%d",
3596 p_data->dch_abort_ind.mcl_handle );
3597 btif_hl_proc_abort_ind(p_data->dch_abort_ind.mcl_handle);
3598 break;
3599 case BTA_HL_DCH_ABORT_CFM_EVT:
3600 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_ABORT_CFM_EVT");
3601 BTIF_TRACE_DEBUG("mcl_handle=%d status =%d",
3602 p_data->dch_abort_cfm.mcl_handle,
3603 p_data->dch_abort_cfm.status);
3604 if (p_data->dch_abort_cfm.status == BTA_HL_STATUS_OK)
3605 {
3606 btif_hl_proc_abort_cfm(p_data->dch_abort_ind.mcl_handle);
3607 }
3608 break;
3609
3610 case BTA_HL_DCH_SEND_DATA_CFM_EVT:
3611 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_SEND_DATA_CFM_EVT");
3612 BTIF_TRACE_DEBUG("mdl_handle=0x%x status =%d",
3613 p_data->dch_send_data_cfm.mdl_handle,
3614 p_data->dch_send_data_cfm.status);
3615 btif_hl_proc_send_data_cfm(p_data->dch_send_data_cfm.mdl_handle,
3616 p_data->dch_send_data_cfm.status);
3617 break;
3618
3619 case BTA_HL_DCH_RCV_DATA_IND_EVT:
3620 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_RCV_DATA_IND_EVT");
3621 BTIF_TRACE_DEBUG("mdl_handle=0x%x ",
3622 p_data->dch_rcv_data_ind.mdl_handle);
3623 /* do nothing here */
3624 break;
3625
3626 default:
3627 BTIF_TRACE_DEBUG("Unknown Event (0x%02x)...", event);
3628 break;
3629 }
3630 }
3631
3632 /*******************************************************************************
3633 **
3634 ** Function btif_hl_cback
3635 **
3636 ** Description Callback function for HL events
3637 **
3638 ** Returns void
3639 **
3640 *******************************************************************************/
btif_hl_cback(tBTA_HL_EVT event,tBTA_HL * p_data)3641 static void btif_hl_cback(tBTA_HL_EVT event, tBTA_HL *p_data){
3642 bt_status_t status;
3643 int param_len = 0;
3644 BTIF_TRACE_DEBUG("%s event %d", __FUNCTION__, event);
3645 btif_hl_display_calling_process_name();
3646 switch (event)
3647 {
3648 case BTA_HL_REGISTER_CFM_EVT:
3649 param_len = sizeof(tBTA_HL_REGISTER_CFM);
3650 break;
3651 case BTA_HL_SDP_INFO_IND_EVT:
3652 param_len = sizeof(tBTA_HL_SDP_INFO_IND);
3653 break;
3654 case BTA_HL_DEREGISTER_CFM_EVT:
3655 param_len = sizeof(tBTA_HL_DEREGISTER_CFM);
3656 break;
3657 case BTA_HL_SDP_QUERY_CFM_EVT:
3658 param_len = sizeof(tBTA_HL_SDP_QUERY_CFM);
3659 break;
3660 case BTA_HL_CCH_OPEN_CFM_EVT:
3661 param_len = sizeof(tBTA_HL_CCH_OPEN_CFM);
3662 break;
3663 case BTA_HL_DCH_OPEN_CFM_EVT:
3664 param_len = sizeof(tBTA_HL_DCH_OPEN_CFM);
3665 break;
3666 case BTA_HL_CCH_OPEN_IND_EVT:
3667 param_len = sizeof(tBTA_HL_CCH_OPEN_IND);
3668 break;
3669 case BTA_HL_DCH_CREATE_IND_EVT:
3670 param_len = sizeof(tBTA_HL_DCH_CREATE_IND);
3671 break;
3672 case BTA_HL_DCH_OPEN_IND_EVT:
3673 param_len = sizeof(tBTA_HL_DCH_OPEN_IND);
3674 break;
3675 case BTA_HL_DELETE_MDL_IND_EVT:
3676 param_len = sizeof(tBTA_HL_MDL_IND);
3677 break;
3678 case BTA_HL_DELETE_MDL_CFM_EVT:
3679 param_len = sizeof(tBTA_HL_MDL_CFM);
3680 break;
3681 case BTA_HL_DCH_RECONNECT_CFM_EVT:
3682 param_len = sizeof(tBTA_HL_DCH_OPEN_CFM);
3683 break;
3684 case BTA_HL_CCH_CLOSE_CFM_EVT:
3685 param_len = sizeof(tBTA_HL_MCL_CFM);
3686 break;
3687 case BTA_HL_CCH_CLOSE_IND_EVT:
3688 param_len = sizeof(tBTA_HL_CCH_CLOSE_IND);
3689 break;
3690 case BTA_HL_DCH_CLOSE_IND_EVT:
3691 param_len = sizeof(tBTA_HL_DCH_CLOSE_IND);
3692 break;
3693 case BTA_HL_DCH_CLOSE_CFM_EVT:
3694 param_len = sizeof(tBTA_HL_MDL_CFM);
3695 break;
3696 case BTA_HL_DCH_ECHO_TEST_CFM_EVT:
3697 param_len = sizeof(tBTA_HL_MCL_CFM);
3698 break;
3699 case BTA_HL_DCH_RECONNECT_IND_EVT:
3700 param_len = sizeof(tBTA_HL_DCH_OPEN_IND);
3701 break;
3702 case BTA_HL_CONG_CHG_IND_EVT:
3703 param_len = sizeof(tBTA_HL_DCH_CONG_IND);
3704 break;
3705 case BTA_HL_DCH_ABORT_IND_EVT:
3706 param_len = sizeof(tBTA_HL_MCL_IND);
3707 break;
3708 case BTA_HL_DCH_ABORT_CFM_EVT:
3709 param_len = sizeof(tBTA_HL_MCL_CFM);
3710 break;
3711 case BTA_HL_DCH_SEND_DATA_CFM_EVT:
3712 param_len = sizeof(tBTA_HL_MDL_CFM);
3713 break;
3714 case BTA_HL_DCH_RCV_DATA_IND_EVT:
3715 param_len = sizeof(tBTA_HL_MDL_IND);
3716 break;
3717 default:
3718 param_len = sizeof(tBTA_HL_MDL_IND);
3719 break;
3720 }
3721 status = btif_transfer_context(btif_hl_upstreams_evt, (uint16_t)event, (void*)p_data, param_len, NULL);
3722
3723 /* catch any failed context transfers */
3724 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
3725 }
3726
3727 /*******************************************************************************
3728 **
3729 ** Function btif_hl_upstreams_ctrl_evt
3730 **
3731 ** Description Callback function for HL control events in the BTIF task context
3732 **
3733 ** Returns void
3734 **
3735 *******************************************************************************/
btif_hl_upstreams_ctrl_evt(UINT16 event,char * p_param)3736 static void btif_hl_upstreams_ctrl_evt(UINT16 event, char* p_param){
3737 tBTA_HL_CTRL *p_data = (tBTA_HL_CTRL *) p_param;
3738 UINT8 i;
3739 tBTA_HL_REG_PARAM reg_param;
3740 btif_hl_app_cb_t *p_acb;
3741
3742 BTIF_TRACE_DEBUG("%s event %d", __FUNCTION__, event);
3743 btif_hl_display_calling_process_name();
3744
3745 switch ( event )
3746 {
3747 case BTA_HL_CTRL_ENABLE_CFM_EVT:
3748 BTIF_TRACE_DEBUG("Rcv BTA_HL_CTRL_ENABLE_CFM_EVT");
3749 BTIF_TRACE_DEBUG("status=%d", p_data->enable_cfm.status);
3750
3751 if (p_data->enable_cfm.status == BTA_HL_STATUS_OK)
3752 {
3753 btif_hl_set_state(BTIF_HL_STATE_ENABLED);
3754
3755 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
3756 {
3757 p_acb = BTIF_HL_GET_APP_CB_PTR(i);
3758 if (p_acb->in_use && p_acb->reg_pending)
3759 {
3760 p_acb->reg_pending = FALSE;
3761 reg_param.dev_type = p_acb->dev_type;
3762 reg_param.sec_mask = BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT;
3763 reg_param.p_srv_name = p_acb->srv_name;
3764 reg_param.p_srv_desp = p_acb->srv_desp;
3765 reg_param.p_provider_name = p_acb->provider_name;
3766
3767 BTIF_TRACE_DEBUG("Register pending app_id=%d", p_acb->app_id);
3768 btif_hl_proc_reg_request (i, p_acb->app_id, ®_param, btif_hl_cback);
3769 }
3770 }
3771 }
3772
3773 break;
3774 case BTA_HL_CTRL_DISABLE_CFM_EVT:
3775 BTIF_TRACE_DEBUG("Rcv BTA_HL_CTRL_DISABLE_CFM_EVT");
3776 BTIF_TRACE_DEBUG("status=%d",
3777 p_data->disable_cfm.status);
3778
3779 if (p_data->disable_cfm.status == BTA_HL_STATUS_OK)
3780 {
3781 for (size_t i = 0; i < BTA_HL_NUM_APPS; i++) {
3782 for (size_t j = 0; j < BTA_HL_NUM_MCLS; j++) {
3783 alarm_free(p_btif_hl_cb->acb[i].mcb[j].cch_timer);
3784 }
3785 }
3786 memset(p_btif_hl_cb, 0, sizeof(btif_hl_cb_t));
3787 btif_hl_set_state(BTIF_HL_STATE_DISABLED);
3788 }
3789
3790 break;
3791 default:
3792 break;
3793 }
3794 }
3795
3796 /*******************************************************************************
3797 **
3798 ** Function btif_hl_ctrl_cback
3799 **
3800 ** Description Callback function for HL control events
3801 **
3802 ** Returns void
3803 **
3804 *******************************************************************************/
btif_hl_ctrl_cback(tBTA_HL_CTRL_EVT event,tBTA_HL_CTRL * p_data)3805 static void btif_hl_ctrl_cback(tBTA_HL_CTRL_EVT event, tBTA_HL_CTRL *p_data){
3806 bt_status_t status;
3807 int param_len = 0;
3808
3809 BTIF_TRACE_DEBUG("%s event %d", __FUNCTION__, event);
3810 btif_hl_display_calling_process_name();
3811
3812 switch ( event )
3813 {
3814 case BTA_HL_CTRL_ENABLE_CFM_EVT:
3815 case BTA_HL_CTRL_DISABLE_CFM_EVT:
3816 param_len = sizeof(tBTA_HL_CTRL_ENABLE_DISABLE);
3817 break;
3818 default:
3819 break;
3820 }
3821
3822 status = btif_transfer_context(btif_hl_upstreams_ctrl_evt, (uint16_t)event, (void*)p_data, param_len, NULL);
3823 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
3824 }
3825 /*******************************************************************************
3826 **
3827 ** Function connect_channel
3828 **
3829 ** Description connect a data channel
3830 **
3831 ** Returns bt_status_t
3832 **
3833 *******************************************************************************/
connect_channel(int app_id,bt_bdaddr_t * bd_addr,int mdep_cfg_index,int * channel_id)3834 static bt_status_t connect_channel(int app_id, bt_bdaddr_t *bd_addr, int mdep_cfg_index, int *channel_id){
3835 UINT8 app_idx, mcl_idx;
3836 btif_hl_app_cb_t *p_acb = NULL;
3837 btif_hl_pending_chan_cb_t *p_pcb = NULL;
3838 btif_hl_mcl_cb_t *p_mcb=NULL;
3839 bt_status_t status = BT_STATUS_SUCCESS;
3840 tBTA_HL_DCH_OPEN_PARAM dch_open;
3841 BD_ADDR bda;
3842 UINT8 i;
3843
3844 CHECK_BTHL_INIT();
3845 BTIF_TRACE_EVENT("%s", __FUNCTION__);
3846 btif_hl_display_calling_process_name();
3847
3848 for (i=0; i<6; i++)
3849 {
3850 bda[i] = (UINT8) bd_addr->address[i];
3851 }
3852 if (btif_hl_find_app_idx(((UINT8)app_id), &app_idx))
3853 {
3854 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
3855 if (btif_hl_find_mcl_idx(app_idx, bda , &mcl_idx))
3856 {
3857 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
3858 if (p_mcb->is_connected)
3859 {
3860 dch_open.ctrl_psm = p_mcb->ctrl_psm;
3861 dch_open.local_mdep_id = p_acb->sup_feature.mdep[mdep_cfg_index].mdep_id;
3862 BTIF_TRACE_DEBUG("connect_channel: app_idx =%d, mdep_cfg_indx =%d, mdep_id =%d app_id= %d", app_idx,
3863 mdep_cfg_index, dch_open.local_mdep_id, app_id);
3864 if (btif_hl_find_peer_mdep_id(p_acb->app_id, p_mcb->bd_addr,
3865 p_acb->sup_feature.mdep[mdep_cfg_index].mdep_cfg.mdep_role,
3866 p_acb->sup_feature.mdep[mdep_cfg_index].mdep_cfg.data_cfg[0].data_type, &dch_open.peer_mdep_id ))
3867 {
3868 dch_open.local_cfg = p_acb->channel_type[mdep_cfg_index];
3869 if ((p_acb->sup_feature.mdep[mdep_cfg_index].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
3870 && !btif_hl_is_the_first_reliable_existed(app_idx,mcl_idx))
3871 {
3872 dch_open.local_cfg = BTA_HL_DCH_CFG_RELIABLE;
3873 }
3874 dch_open.sec_mask = (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT);
3875
3876 if( !btif_hl_dch_open(p_acb->app_id, bda, &dch_open,
3877 mdep_cfg_index, BTIF_HL_PEND_DCH_OP_OPEN, channel_id ))
3878 {
3879 status = BT_STATUS_FAIL;
3880 BTIF_TRACE_EVENT("%s loc0 status = BT_STATUS_FAIL", __FUNCTION__);
3881 }
3882 }
3883 else
3884 {
3885 p_mcb->cch_oper = BTIF_HL_CCH_OP_MDEP_FILTERING;
3886
3887 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
3888 p_pcb->in_use = TRUE;
3889 p_pcb->mdep_cfg_idx = mdep_cfg_index;
3890 memcpy(p_pcb->bd_addr, bda, sizeof(BD_ADDR));
3891 p_pcb->op = BTIF_HL_PEND_DCH_OP_OPEN;
3892 BTA_HlSdpQuery(app_id,p_acb->app_handle, bda);
3893 }
3894 }
3895 else
3896 {
3897 status = BT_STATUS_FAIL;
3898 }
3899 }
3900 else
3901 {
3902 p_acb->filter.num_elems =1;
3903 p_acb->filter.elem[0].data_type = p_acb->sup_feature.mdep[mdep_cfg_index].mdep_cfg.data_cfg[mdep_cfg_index].data_type;
3904 if (p_acb->sup_feature.mdep[mdep_cfg_index].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SINK)
3905 p_acb->filter.elem[0].peer_mdep_role = BTA_HL_MDEP_ROLE_SOURCE;
3906 else
3907 p_acb->filter.elem[0].peer_mdep_role = BTA_HL_MDEP_ROLE_SINK;
3908
3909 if ( !btif_hl_cch_open(p_acb->app_id, bda, 0, mdep_cfg_index,
3910 BTIF_HL_PEND_DCH_OP_OPEN,
3911 channel_id))
3912 {
3913 status = BT_STATUS_FAIL;
3914 }
3915 }
3916 }
3917 else
3918 {
3919 status = BT_STATUS_FAIL;
3920 }
3921
3922 BTIF_TRACE_DEBUG("%s status=%d channel_id=0x%08x", __FUNCTION__, status, *channel_id);
3923
3924 return status;
3925 }
3926 /*******************************************************************************
3927 **
3928 ** Function destroy_channel
3929 **
3930 ** Description destroy a data channel
3931 **
3932 ** Returns bt_status_t
3933 **
3934 *******************************************************************************/
destroy_channel(int channel_id)3935 static bt_status_t destroy_channel(int channel_id){
3936 UINT8 app_idx, mcl_idx, mdl_cfg_idx, mdep_cfg_idx = 0;
3937 bt_status_t status = BT_STATUS_SUCCESS;
3938 btif_hl_mdl_cfg_t *p_mdl;
3939 btif_hl_mcl_cb_t *p_mcb;
3940 btif_hl_app_cb_t *p_acb;
3941
3942 CHECK_BTHL_INIT();
3943 BTIF_TRACE_EVENT("%s channel_id=0x%08x", __FUNCTION__, channel_id);
3944 btif_hl_display_calling_process_name();
3945
3946 if (btif_hl_if_channel_setup_pending(channel_id, &app_idx, &mcl_idx))
3947 {
3948 btif_hl_dch_abort(app_idx, mcl_idx);
3949 }
3950 else
3951 {
3952 if (btif_hl_find_mdl_cfg_idx_using_channel_id(channel_id, &app_idx, &mdl_cfg_idx))
3953 // if(btif_hl_find_mdl_idx_using_channel_id(channel_id, &app_idx,&mcl_idx, &mdl_idx))
3954 {
3955 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
3956 if (!p_acb->delete_mdl.active)
3957 {
3958 p_mdl =BTIF_HL_GET_MDL_CFG_PTR(app_idx, mdl_cfg_idx);
3959 p_acb->delete_mdl.active = TRUE;
3960 p_acb->delete_mdl.mdl_id = p_mdl->base.mdl_id;
3961 p_acb->delete_mdl.channel_id = channel_id;
3962 p_acb->delete_mdl.mdep_cfg_idx = p_mdl->extra.mdep_cfg_idx;
3963 memcpy(p_acb->delete_mdl.bd_addr, p_mdl->base.peer_bd_addr,sizeof(BD_ADDR));
3964
3965 if (btif_hl_find_mcl_idx(app_idx, p_mdl->base.peer_bd_addr, &mcl_idx))
3966 {
3967 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
3968 if (p_mcb->is_connected)
3969 {
3970 BTIF_TRACE_DEBUG("calling BTA_HlDeleteMdl mdl_id=%d",p_acb->delete_mdl.mdl_id );
3971 BTA_HlDeleteMdl(p_mcb->mcl_handle, p_acb->delete_mdl.mdl_id);
3972 }
3973 else
3974 {
3975 status = BT_STATUS_FAIL;
3976 }
3977 }
3978 else
3979 {
3980 BTIF_TRACE_DEBUG("btif_hl_delete_mdl calling btif_hl_cch_open" );
3981 mdep_cfg_idx = p_mdl->extra.mdep_cfg_idx;
3982 p_acb->filter.num_elems =1;
3983 p_acb->filter.elem[0].data_type = p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg.data_cfg[mdep_cfg_idx].data_type;
3984 if (p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SINK)
3985 p_acb->filter.elem[0].peer_mdep_role = BTA_HL_MDEP_ROLE_SOURCE;
3986 else
3987 p_acb->filter.elem[0].peer_mdep_role = BTA_HL_MDEP_ROLE_SINK;
3988 if (btif_hl_cch_open(p_acb->app_id, p_acb->delete_mdl.bd_addr, 0,
3989 mdep_cfg_idx,
3990 BTIF_HL_PEND_DCH_OP_DELETE_MDL, NULL))
3991 {
3992 status = BT_STATUS_FAIL;
3993 }
3994 }
3995
3996 if ( status == BT_STATUS_FAIL)
3997 {
3998 /* fail for now */
3999 btif_hl_clean_delete_mdl(&p_acb->delete_mdl);
4000 }
4001 }
4002 else
4003 {
4004 status = BT_STATUS_BUSY;
4005 }
4006 }
4007 else
4008 {
4009 status = BT_STATUS_FAIL;
4010 }
4011
4012 }
4013 return status;
4014 }
4015 /*******************************************************************************
4016 **
4017 ** Function unregister_application
4018 **
4019 ** Description unregister an HDP application
4020 **
4021 ** Returns bt_status_t
4022 **
4023 *******************************************************************************/
unregister_application(int app_id)4024 static bt_status_t unregister_application(int app_id){
4025 UINT8 app_idx;
4026 int len;
4027 bt_status_t status = BT_STATUS_SUCCESS;
4028 btif_hl_evt_cb_t evt_param;
4029
4030 CHECK_BTHL_INIT();
4031 BTIF_TRACE_EVENT("%s app_id=%d", __FUNCTION__, app_id);
4032 btif_hl_display_calling_process_name();
4033
4034 if (btif_hl_find_app_idx(((UINT8)app_id), &app_idx))
4035 {
4036 evt_param.unreg.app_idx = app_idx;
4037 reg_counter --;
4038 len = sizeof(btif_hl_unreg_t);
4039 status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_UNREG_APP,
4040 (char*) &evt_param, len, NULL);
4041 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
4042 }
4043 else
4044 {
4045 status = BT_STATUS_FAIL;
4046 }
4047
4048 BTIF_TRACE_DEBUG("de-reg return status=%d", status);
4049 return status;
4050 }
4051 /*******************************************************************************
4052 **
4053 ** Function register_application
4054 **
4055 ** Description register an HDP application
4056 **
4057 ** Returns bt_status_t
4058 **
4059 *******************************************************************************/
register_application(bthl_reg_param_t * p_reg_param,int * app_id)4060 static bt_status_t register_application(bthl_reg_param_t *p_reg_param, int *app_id){
4061 btif_hl_app_cb_t *p_acb;
4062 tBTA_HL_SUP_FEATURE *p_sup;
4063 tBTA_HL_MDEP_CFG *p_cfg;
4064 tBTA_HL_MDEP_DATA_TYPE_CFG *p_data;
4065 UINT8 app_idx=0, i=0;
4066 bthl_mdep_cfg_t *p_mdep_cfg;
4067 bt_status_t status = BT_STATUS_SUCCESS;
4068 btif_hl_evt_cb_t evt_param;
4069 int len;
4070
4071 CHECK_BTHL_INIT();
4072 BTIF_TRACE_EVENT("%s", __FUNCTION__);
4073 btif_hl_display_calling_process_name();
4074
4075 if (btif_hl_get_state() == BTIF_HL_STATE_DISABLED)
4076 {
4077 btif_hl_init();
4078 btif_hl_set_state(BTIF_HL_STATE_ENABLING);
4079 BTA_HlEnable(btif_hl_ctrl_cback);
4080 }
4081
4082 if (!btif_hl_find_avail_app_idx(&app_idx))
4083 {
4084 BTIF_TRACE_ERROR("Unable to allocate a new application control block");
4085 return BT_STATUS_FAIL;
4086 }
4087
4088 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
4089 p_acb->in_use = TRUE;
4090
4091 p_acb->app_id = btif_hl_get_next_app_id();
4092
4093 if (p_reg_param->application_name != NULL )
4094 strncpy(p_acb->application_name, p_reg_param->application_name, BTIF_HL_APPLICATION_NAME_LEN);
4095
4096 if (p_reg_param->provider_name != NULL )
4097 strncpy(p_acb->provider_name, p_reg_param->provider_name, BTA_PROVIDER_NAME_LEN);
4098
4099 if (p_reg_param->srv_name != NULL )
4100 strncpy(p_acb->srv_name, p_reg_param->srv_name, BTA_SERVICE_NAME_LEN);
4101
4102 if (p_reg_param->srv_desp != NULL )
4103 strncpy(p_acb->srv_desp, p_reg_param->srv_desp, BTA_SERVICE_DESP_LEN);
4104
4105 p_sup = &p_acb->sup_feature;
4106 p_sup->advertize_source_sdp = TRUE;
4107 p_sup->echo_cfg.max_rx_apdu_size = BTIF_HL_ECHO_MAX_TX_RX_APDU_SIZE;
4108 p_sup->echo_cfg.max_tx_apdu_size = BTIF_HL_ECHO_MAX_TX_RX_APDU_SIZE;
4109 p_sup->num_of_mdeps = p_reg_param->number_of_mdeps;
4110
4111 for (i=0, p_mdep_cfg = p_reg_param->mdep_cfg ; i< p_sup->num_of_mdeps; i++, p_mdep_cfg++ )
4112 {
4113 p_cfg = &p_sup->mdep[i].mdep_cfg;
4114 p_cfg->num_of_mdep_data_types = 1;
4115 p_data = &p_cfg->data_cfg[0];
4116
4117 if ( !btif_hl_get_bta_mdep_role(p_mdep_cfg->mdep_role, &(p_cfg->mdep_role)))
4118 {
4119 BTIF_TRACE_ERROR("Invalid mdep_role=%d", p_mdep_cfg->mdep_role);
4120 status = BT_STATUS_FAIL;
4121 break;
4122 }
4123 else
4124 {
4125 if (p_cfg->mdep_role == BTA_HL_MDEP_ROLE_SINK )
4126 p_sup->app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SINK;
4127 else
4128 p_sup->app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SOURCE;
4129
4130 if ( (p_sup->app_role_mask & BTA_HL_MDEP_ROLE_MASK_SINK) &&
4131 (p_sup->app_role_mask & BTA_HL_MDEP_ROLE_MASK_SINK) )
4132 {
4133 p_acb->dev_type = BTA_HL_DEVICE_TYPE_DUAL;
4134 }
4135 else if ( p_sup->app_role_mask & BTA_HL_MDEP_ROLE_MASK_SINK )
4136 p_acb->dev_type = BTA_HL_DEVICE_TYPE_SINK;
4137 else
4138
4139 p_acb->dev_type = BTA_HL_DEVICE_TYPE_SOURCE;
4140
4141 p_data->data_type = (UINT16) p_mdep_cfg->data_type;
4142 p_data->max_rx_apdu_size = btif_hl_get_max_rx_apdu_size(p_cfg->mdep_role, p_data->data_type);
4143 p_data->max_tx_apdu_size = btif_hl_get_max_tx_apdu_size(p_cfg->mdep_role, p_data->data_type);
4144
4145 if (p_mdep_cfg->mdep_description != NULL )
4146 strncpy(p_data->desp, p_mdep_cfg->mdep_description, BTA_SERVICE_DESP_LEN);
4147
4148 if ( !btif_hl_get_bta_channel_type(p_mdep_cfg->channel_type, &(p_acb->channel_type[i])))
4149 {
4150 BTIF_TRACE_ERROR("Invalid channel_type=%d", p_mdep_cfg->channel_type);
4151 status = BT_STATUS_FAIL;
4152 break;
4153 }
4154 }
4155 }
4156
4157 if (status == BT_STATUS_SUCCESS)
4158 {
4159 *app_id = (int) p_acb->app_id;
4160 evt_param.reg.app_idx = app_idx;
4161 len = sizeof(btif_hl_reg_t);
4162 p_acb->reg_pending = TRUE;
4163 reg_counter++;
4164 BTIF_TRACE_DEBUG("calling btif_transfer_context status=%d app_id=%d", status, *app_id);
4165 status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_REG_APP,
4166 (char*) &evt_param, len, NULL);
4167 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
4168
4169 }
4170 else
4171 {
4172 btif_hl_free_app_idx(app_idx);
4173 }
4174
4175 BTIF_TRACE_DEBUG("register_application status=%d app_id=%d", status, *app_id);
4176 return status;
4177 }
4178
4179 /*******************************************************************************
4180 **
4181 ** Function btif_hl_save_mdl_cfg
4182 **
4183 ** Description Save the MDL configuration
4184 **
4185 ** Returns BOOLEAN
4186 **
4187 *******************************************************************************/
btif_hl_save_mdl_cfg(UINT8 mdep_id,UINT8 item_idx,tBTA_HL_MDL_CFG * p_mdl_cfg)4188 BOOLEAN btif_hl_save_mdl_cfg(UINT8 mdep_id, UINT8 item_idx,
4189 tBTA_HL_MDL_CFG *p_mdl_cfg){
4190 btif_hl_mdl_cfg_t *p_mdl=NULL;
4191 BOOLEAN success = FALSE;
4192 btif_hl_app_cb_t *p_acb;
4193 btif_hl_mcl_cb_t *p_mcb;
4194 UINT8 app_idx, mcl_idx, len;
4195 bt_status_t bt_status;
4196 btif_hl_evt_cb_t evt_param;
4197 int *p_channel_id;
4198
4199 BTIF_TRACE_DEBUG("%s mdep_id=%d item_idx=%d, local_mdep_id=%d mdl_id=0x%x dch_mode=%d",
4200 __FUNCTION__, mdep_id, item_idx, p_mdl_cfg->local_mdep_id,
4201 p_mdl_cfg->mdl_id, p_mdl_cfg->dch_mode );
4202
4203 if(btif_hl_find_app_idx_using_mdepId(mdep_id,&app_idx))
4204 {
4205 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
4206 p_mdl = BTIF_HL_GET_MDL_CFG_PTR(app_idx, item_idx);
4207 p_channel_id = BTIF_HL_GET_MDL_CFG_CHANNEL_ID_PTR(app_idx, item_idx);
4208 if (p_mdl)
4209 {
4210 memcpy(&p_mdl->base, p_mdl_cfg, sizeof(tBTA_HL_MDL_CFG));
4211 if (btif_hl_find_mcl_idx(app_idx, p_mdl->base.peer_bd_addr , &mcl_idx))
4212 {
4213 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
4214 if (p_mcb->pcb.in_use)
4215 *p_channel_id = p_mcb->pcb.channel_id;
4216 else
4217 *p_channel_id = btif_hl_get_next_channel_id(p_acb->app_id);
4218 p_mdl->extra.mdep_cfg_idx = p_mcb->pcb.mdep_cfg_idx;
4219 p_mdl->extra.data_type = p_acb->sup_feature.mdep[p_mcb->pcb.mdep_cfg_idx].mdep_cfg.data_cfg[0].data_type;
4220
4221 if (!btif_hl_find_peer_mdep_id(p_acb->app_id, p_mcb->bd_addr,
4222 p_acb->sup_feature.mdep[p_mcb->pcb.mdep_cfg_idx].mdep_cfg.mdep_role,
4223 p_acb->sup_feature.mdep[p_mcb->pcb.mdep_cfg_idx].mdep_cfg.data_cfg[0].data_type,
4224 &p_mdl->extra.peer_mdep_id))
4225 {
4226 p_mdl->extra.peer_mdep_id = BTA_HL_INVALID_MDEP_ID;
4227 }
4228 BTIF_TRACE_DEBUG("%s app_idx=%d item_idx=%d mld_id=0x%x",
4229 __FUNCTION__, app_idx, item_idx, p_mdl->base.mdl_id);
4230 evt_param.update_mdl.app_idx = app_idx;
4231 len = sizeof(btif_hl_update_mdl_t);
4232 BTIF_TRACE_DEBUG("send BTIF_HL_UPDATE_MDL event app_idx=%d ",app_idx);
4233 if ((bt_status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_UPDATE_MDL,
4234 (char*) &evt_param, len, NULL)) == BT_STATUS_SUCCESS)
4235 {
4236 success = TRUE;
4237 }
4238 ASSERTC(bt_status == BT_STATUS_SUCCESS, "context transfer failed", bt_status);
4239 }
4240 }
4241 }
4242 BTIF_TRACE_DEBUG("%s success=%d ",__FUNCTION__, success );
4243
4244 return success;
4245 }
4246
4247 /*******************************************************************************
4248 **
4249 ** Function btif_hl_delete_mdl_cfg
4250 **
4251 ** Description Delete the MDL configuration
4252 **
4253 ** Returns BOOLEAN
4254 **
4255 *******************************************************************************/
btif_hl_delete_mdl_cfg(UINT8 mdep_id,UINT8 item_idx)4256 BOOLEAN btif_hl_delete_mdl_cfg(UINT8 mdep_id, UINT8 item_idx){
4257 btif_hl_mdl_cfg_t *p_mdl=NULL;
4258 BOOLEAN success = FALSE;
4259 UINT8 app_idx, len;
4260 bt_status_t bt_status;
4261 btif_hl_evt_cb_t evt_param;
4262
4263 if(btif_hl_find_app_idx_using_mdepId(mdep_id,&app_idx))
4264 {
4265 p_mdl = BTIF_HL_GET_MDL_CFG_PTR(app_idx, item_idx);
4266 if (p_mdl)
4267 {
4268 memset(p_mdl, 0, sizeof(btif_hl_mdl_cfg_t));
4269 evt_param.update_mdl.app_idx = app_idx;
4270 len = sizeof(btif_hl_update_mdl_t);
4271 BTIF_TRACE_DEBUG("send BTIF_HL_UPDATE_MDL event app_idx=%d ",app_idx);
4272 if ((bt_status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_UPDATE_MDL,
4273 (char*) &evt_param, len, NULL)) == BT_STATUS_SUCCESS)
4274 {
4275 success = TRUE;
4276 }
4277 ASSERTC(bt_status == BT_STATUS_SUCCESS, "context transfer failed", bt_status);
4278 }
4279 }
4280
4281 BTIF_TRACE_DEBUG("%s success=%d ",__FUNCTION__, success );
4282 return success;
4283 }
4284
4285 /*******************************************************************************
4286 **
4287 ** Function init
4288 **
4289 ** Description initializes the hl interface
4290 **
4291 ** Returns bt_status_t
4292 **
4293 *******************************************************************************/
init(bthl_callbacks_t * callbacks)4294 static bt_status_t init( bthl_callbacks_t* callbacks ){
4295 bt_status_t status = BT_STATUS_SUCCESS;
4296
4297 BTIF_TRACE_EVENT("%s", __FUNCTION__);
4298 btif_hl_display_calling_process_name();
4299 bt_hl_callbacks_cb = *callbacks;
4300 bt_hl_callbacks = &bt_hl_callbacks_cb;
4301 btif_hl_soc_thread_init();
4302 reg_counter = 0;
4303 return status;
4304 }
4305 /*******************************************************************************
4306 **
4307 ** Function cleanup
4308 **
4309 ** Description Closes the HL interface
4310 **
4311 ** Returns void
4312 **
4313 *******************************************************************************/
cleanup(void)4314 static void cleanup( void ){
4315 BTIF_TRACE_EVENT("%s", __FUNCTION__);
4316 btif_hl_display_calling_process_name();
4317 if (bt_hl_callbacks)
4318 {
4319 btif_disable_service(BTA_HDP_SERVICE_ID);
4320 bt_hl_callbacks = NULL;
4321 reg_counter = 0;
4322 }
4323
4324 btif_hl_disable();
4325 btif_hl_close_select_thread();
4326 }
4327
4328 static const bthl_interface_t bthlInterface = {
4329 sizeof(bthl_interface_t),
4330 init,
4331 register_application,
4332 unregister_application,
4333 connect_channel,
4334 destroy_channel,
4335 cleanup,
4336 };
4337
4338 /*******************************************************************************
4339 **
4340 ** Function btif_hl_get_interface
4341 **
4342 ** Description Get the hl callback interface
4343 **
4344 ** Returns bthf_interface_t
4345 **
4346 *******************************************************************************/
btif_hl_get_interface()4347 const bthl_interface_t *btif_hl_get_interface(){
4348 BTIF_TRACE_EVENT("%s", __FUNCTION__);
4349 return &bthlInterface;
4350 }
4351
4352 /*******************************************************************************
4353 **
4354 ** Function btif_hl_update_maxfd
4355 **
4356 ** Description Update the max fd if the input fd is greater than the current max fd
4357 **
4358 ** Returns int
4359 **
4360 *******************************************************************************/
btif_hl_update_maxfd(int max_org_s)4361 int btif_hl_update_maxfd(int max_org_s) {
4362 int maxfd = max_org_s;
4363
4364 BTIF_TRACE_DEBUG("btif_hl_update_maxfd max_org_s= %d", max_org_s);
4365 for (const list_node_t *node = list_begin(soc_queue);
4366 node != list_end(soc_queue); node = list_next(node)) {
4367 btif_hl_soc_cb_t *p_scb = list_node(node);
4368 if (maxfd < p_scb->max_s) {
4369 maxfd = p_scb->max_s;
4370 BTIF_TRACE_DEBUG("btif_hl_update_maxfd maxfd=%d", maxfd);
4371 }
4372 }
4373
4374 BTIF_TRACE_DEBUG("btif_hl_update_maxfd final *p_max_s=%d", maxfd);
4375 return maxfd;
4376 }
4377 /*******************************************************************************
4378 **
4379 ** Function btif_hl_get_socket_state
4380 **
4381 ** Description get socket state
4382 **
4383 ** Returns btif_hl_soc_state_t
4384 **
4385 *******************************************************************************/
btif_hl_get_socket_state(btif_hl_soc_cb_t * p_scb)4386 btif_hl_soc_state_t btif_hl_get_socket_state(btif_hl_soc_cb_t *p_scb){
4387 BTIF_TRACE_DEBUG("btif_hl_get_socket_state state=%d", p_scb->state);
4388 return p_scb->state;
4389 }
4390 /*******************************************************************************
4391 **
4392 ** Function btif_hl_set_socket_state
4393 **
4394 ** Description set socket state
4395 **
4396 ** Returns void
4397 **
4398 *******************************************************************************/
btif_hl_set_socket_state(btif_hl_soc_cb_t * p_scb,btif_hl_soc_state_t new_state)4399 void btif_hl_set_socket_state(btif_hl_soc_cb_t *p_scb, btif_hl_soc_state_t new_state){
4400 BTIF_TRACE_DEBUG("btif_hl_set_socket_state %d---->%d", p_scb->state, new_state);
4401 p_scb->state = new_state;
4402 }
4403 /*******************************************************************************
4404 **
4405 ** Function btif_hl_release_mcl_sockets
4406 **
4407 ** Description Release all sockets on the MCL
4408 **
4409 ** Returns void
4410 **
4411 *******************************************************************************/
btif_hl_release_mcl_sockets(UINT8 app_idx,UINT8 mcl_idx)4412 void btif_hl_release_mcl_sockets(UINT8 app_idx, UINT8 mcl_idx){
4413 UINT8 i;
4414 btif_hl_mdl_cb_t *p_dcb;
4415 BOOLEAN found= FALSE;
4416 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
4417 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
4418 {
4419 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, i);
4420 if (p_dcb && p_dcb->in_use && p_dcb->p_scb)
4421 {
4422 BTIF_TRACE_DEBUG("found socket for app_idx=%d mcl_id=%d, mdl_idx=%d", app_idx, mcl_idx, i);
4423 btif_hl_set_socket_state (p_dcb->p_scb, BTIF_HL_SOC_STATE_W4_REL);
4424 p_dcb->p_scb = NULL;
4425 found = TRUE;
4426 }
4427 }
4428 if (found)
4429 btif_hl_select_close_connected();
4430 }
4431 /*******************************************************************************
4432 **
4433 ** Function btif_hl_release_socket
4434 **
4435 ** Description release a specified socket
4436 **
4437 ** Returns void
4438 **
4439 *******************************************************************************/
btif_hl_release_socket(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdl_idx)4440 void btif_hl_release_socket(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx){
4441 btif_hl_soc_cb_t *p_scb = NULL;
4442 btif_hl_mdl_cb_t *p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
4443
4444 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
4445 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d mdl_idx=%d", app_idx, mcl_idx, mdl_idx );
4446
4447 if (p_dcb && p_dcb->p_scb)
4448 {
4449 p_scb = p_dcb->p_scb;
4450 btif_hl_set_socket_state(p_scb, BTIF_HL_SOC_STATE_W4_REL);
4451 p_dcb->p_scb = NULL;
4452 btif_hl_select_close_connected();
4453 }
4454 }
4455 /*******************************************************************************
4456 **
4457 ** Function btif_hl_create_socket
4458 **
4459 ** Description create a socket
4460 **
4461 ** Returns BOOLEAN
4462 **
4463 *******************************************************************************/
btif_hl_create_socket(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdl_idx)4464 BOOLEAN btif_hl_create_socket(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx){
4465 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
4466 btif_hl_mdl_cb_t *p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
4467 BOOLEAN status = FALSE;
4468
4469 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
4470
4471 if (p_dcb) {
4472 btif_hl_soc_cb_t *p_scb =
4473 (btif_hl_soc_cb_t *)osi_malloc(sizeof(btif_hl_soc_cb_t));
4474 if (socketpair(AF_UNIX, SOCK_STREAM, 0, p_scb->socket_id) >= 0) {
4475 BTIF_TRACE_DEBUG("socket id[0]=%d id[1]=%d",p_scb->socket_id[0], p_scb->socket_id[1] );
4476 p_dcb->p_scb = p_scb;
4477 p_scb->app_idx = app_idx;
4478 p_scb->mcl_idx = mcl_idx;
4479 p_scb->mdl_idx = mdl_idx;
4480 p_scb->channel_id = p_dcb->channel_id;
4481 p_scb->mdep_cfg_idx = p_dcb->local_mdep_cfg_idx;
4482 memcpy(p_scb->bd_addr, p_mcb->bd_addr,sizeof(BD_ADDR));
4483 btif_hl_set_socket_state(p_scb, BTIF_HL_SOC_STATE_W4_ADD);
4484 p_scb->max_s = p_scb->socket_id[1];
4485 list_append(soc_queue, (void *)p_scb);
4486 btif_hl_select_wakeup();
4487 status = TRUE;
4488 } else {
4489 osi_free_and_reset((void **)&p_scb);
4490 }
4491 }
4492
4493 BTIF_TRACE_DEBUG("%s status=%d", __FUNCTION__, status);
4494 return status;
4495 }
4496 /*******************************************************************************
4497 **
4498 ** Function btif_hl_add_socket_to_set
4499 **
4500 ** Description Add a socket
4501 **
4502 ** Returns void
4503 **
4504 *******************************************************************************/
btif_hl_add_socket_to_set(fd_set * p_org_set)4505 void btif_hl_add_socket_to_set(fd_set *p_org_set) {
4506 btif_hl_mdl_cb_t *p_dcb = NULL;
4507 btif_hl_mcl_cb_t *p_mcb = NULL;
4508 btif_hl_app_cb_t *p_acb = NULL;
4509 btif_hl_evt_cb_t evt_param;
4510 bt_status_t status;
4511 int len;
4512
4513 BTIF_TRACE_DEBUG("entering %s",__FUNCTION__);
4514
4515 for (const list_node_t *node = list_begin(soc_queue);
4516 node != list_end(soc_queue); node = list_next(node)) {
4517 btif_hl_soc_cb_t *p_scb = list_node(node);
4518
4519 BTIF_TRACE_DEBUG("btif_hl_add_socket_to_set first p_scb=0x%x", p_scb);
4520 if (btif_hl_get_socket_state(p_scb) == BTIF_HL_SOC_STATE_W4_ADD) {
4521 btif_hl_set_socket_state(p_scb, BTIF_HL_SOC_STATE_W4_READ);
4522 FD_SET(p_scb->socket_id[1], p_org_set);
4523 BTIF_TRACE_DEBUG("found and set socket_id=%d is_set=%d",
4524 p_scb->socket_id[1], FD_ISSET(p_scb->socket_id[1], p_org_set));
4525 p_mcb = BTIF_HL_GET_MCL_CB_PTR(p_scb->app_idx, p_scb->mcl_idx);
4526 p_dcb = BTIF_HL_GET_MDL_CB_PTR(p_scb->app_idx, p_scb->mcl_idx, p_scb->mdl_idx);
4527 p_acb = BTIF_HL_GET_APP_CB_PTR(p_scb->app_idx);
4528 if (p_mcb && p_dcb) {
4529 btif_hl_stop_timer_using_handle(p_mcb->mcl_handle);
4530 evt_param.chan_cb.app_id = p_acb->app_id;
4531 memcpy(evt_param.chan_cb.bd_addr, p_mcb->bd_addr, sizeof(BD_ADDR));
4532 evt_param.chan_cb.channel_id = p_dcb->channel_id;
4533 evt_param.chan_cb.fd = p_scb->socket_id[0];
4534 evt_param.chan_cb.mdep_cfg_index = (int ) p_dcb->local_mdep_cfg_idx;
4535 evt_param.chan_cb.cb_state = BTIF_HL_CHAN_CB_STATE_CONNECTED_PENDING;
4536 len = sizeof(btif_hl_send_chan_state_cb_t);
4537 status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_SEND_CONNECTED_CB,
4538 (char*) &evt_param, len, NULL);
4539 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
4540 }
4541 }
4542 }
4543 BTIF_TRACE_DEBUG("leaving %s",__FUNCTION__);
4544 }
4545
4546 /*******************************************************************************
4547 **
4548 ** Function btif_hl_close_socket
4549 **
4550 ** Description close a socket
4551 **
4552 ** Returns void
4553 **
4554 *******************************************************************************/
btif_hl_close_socket(fd_set * p_org_set)4555 void btif_hl_close_socket( fd_set *p_org_set){
4556 BTIF_TRACE_DEBUG("entering %s",__FUNCTION__);
4557 for (const list_node_t *node = list_begin(soc_queue);
4558 node != list_end(soc_queue); node = list_next(node)) {
4559 btif_hl_soc_cb_t *p_scb = list_node(node);
4560 if (btif_hl_get_socket_state(p_scb) == BTIF_HL_SOC_STATE_W4_REL) {
4561 BTIF_TRACE_DEBUG("app_idx=%d mcl_id=%d, mdl_idx=%d",
4562 p_scb->app_idx, p_scb->mcl_idx, p_scb->mdl_idx);
4563 btif_hl_set_socket_state(p_scb, BTIF_HL_SOC_STATE_IDLE);
4564 if (p_scb->socket_id[1] != -1) {
4565 FD_CLR(p_scb->socket_id[1] , p_org_set);
4566 shutdown(p_scb->socket_id[1], SHUT_RDWR);
4567 close(p_scb->socket_id[1]);
4568
4569 btif_hl_evt_cb_t evt_param;
4570 evt_param.chan_cb.app_id = (int) btif_hl_get_app_id(p_scb->channel_id);
4571 memcpy(evt_param.chan_cb.bd_addr, p_scb->bd_addr, sizeof(BD_ADDR));
4572 evt_param.chan_cb.channel_id = p_scb->channel_id;
4573 evt_param.chan_cb.fd = p_scb->socket_id[0];
4574 evt_param.chan_cb.mdep_cfg_index = (int ) p_scb->mdep_cfg_idx;
4575 evt_param.chan_cb.cb_state = BTIF_HL_CHAN_CB_STATE_DISCONNECTED_PENDING;
4576 int len = sizeof(btif_hl_send_chan_state_cb_t);
4577 bt_status_t status = btif_transfer_context (btif_hl_proc_cb_evt,
4578 BTIF_HL_SEND_DISCONNECTED_CB,
4579 (char*) &evt_param, len, NULL);
4580 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
4581 }
4582 }
4583 }
4584
4585 for (const list_node_t *node = list_begin(soc_queue);
4586 node != list_end(soc_queue); ) {
4587 // We may mutate this list so we need keep track of
4588 // the current node and only remove items behind.
4589 btif_hl_soc_cb_t *p_scb = list_node(node);
4590 BTIF_TRACE_DEBUG("p_scb=0x%x", p_scb);
4591 node = list_next(node);
4592 if (btif_hl_get_socket_state(p_scb) == BTIF_HL_SOC_STATE_IDLE) {
4593 btif_hl_mdl_cb_t *p_dcb = BTIF_HL_GET_MDL_CB_PTR(p_scb->app_idx,
4594 p_scb->mcl_idx, p_scb->mdl_idx);
4595 BTIF_TRACE_DEBUG("idle socket app_idx=%d mcl_id=%d, mdl_idx=%d p_dcb->in_use=%d",
4596 p_scb->app_idx, p_scb->mcl_idx, p_scb->mdl_idx, p_dcb->in_use);
4597 list_remove(soc_queue, p_scb);
4598 osi_free(p_scb);
4599 p_dcb->p_scb = NULL;
4600 }
4601 }
4602 BTIF_TRACE_DEBUG("leaving %s",__FUNCTION__);
4603 }
4604
4605 /*******************************************************************************
4606 **
4607 ** Function btif_hl_select_wakeup_callback
4608 **
4609 ** Description Select wakup callback to add or close a socket
4610 **
4611 ** Returns void
4612 **
4613 *******************************************************************************/
4614
btif_hl_select_wakeup_callback(fd_set * p_org_set,int wakeup_signal)4615 void btif_hl_select_wakeup_callback( fd_set *p_org_set , int wakeup_signal){
4616 BTIF_TRACE_DEBUG("entering %s wakeup_signal=0x%04x",__FUNCTION__, wakeup_signal);
4617
4618 if (wakeup_signal == btif_hl_signal_select_wakeup )
4619 {
4620 btif_hl_add_socket_to_set(p_org_set);
4621 }
4622 else if (wakeup_signal == btif_hl_signal_select_close_connected)
4623 {
4624 btif_hl_close_socket(p_org_set);
4625 }
4626 BTIF_TRACE_DEBUG("leaving %s",__FUNCTION__);
4627 }
4628
4629 /*******************************************************************************
4630 **
4631 ** Function btif_hl_select_monitor_callback
4632 **
4633 ** Description Select monitor callback to check pending socket actions
4634 **
4635 ** Returns void
4636 **
4637 *******************************************************************************/
btif_hl_select_monitor_callback(fd_set * p_cur_set,fd_set * p_org_set)4638 void btif_hl_select_monitor_callback(fd_set *p_cur_set ,fd_set *p_org_set) {
4639 UNUSED(p_org_set);
4640
4641 BTIF_TRACE_DEBUG("entering %s",__FUNCTION__);
4642
4643 for (const list_node_t *node = list_begin(soc_queue);
4644 node != list_end(soc_queue); node = list_next(node)) {
4645 btif_hl_soc_cb_t *p_scb = list_node(node);
4646 if (btif_hl_get_socket_state(p_scb) == BTIF_HL_SOC_STATE_W4_READ) {
4647 if (FD_ISSET(p_scb->socket_id[1], p_cur_set)) {
4648 BTIF_TRACE_DEBUG("read data state= BTIF_HL_SOC_STATE_W4_READ");
4649 btif_hl_mdl_cb_t *p_dcb = BTIF_HL_GET_MDL_CB_PTR(p_scb->app_idx,
4650 p_scb->mcl_idx, p_scb->mdl_idx);
4651 assert(p_dcb != NULL);
4652 if (p_dcb->p_tx_pkt) {
4653 BTIF_TRACE_ERROR("Rcv new pkt but the last pkt is still not been"
4654 " sent tx_size=%d", p_dcb->tx_size);
4655 osi_free_and_reset((void **)&p_dcb->p_tx_pkt);
4656 }
4657 p_dcb->p_tx_pkt = osi_malloc(p_dcb->mtu);
4658 ssize_t r;
4659 OSI_NO_INTR(r = recv(p_scb->socket_id[1], p_dcb->p_tx_pkt,
4660 p_dcb->mtu, MSG_DONTWAIT));
4661 if (r > 0) {
4662 BTIF_TRACE_DEBUG("btif_hl_select_monitor_callback send data r =%d", r);
4663 p_dcb->tx_size = r;
4664 BTIF_TRACE_DEBUG("btif_hl_select_monitor_callback send data tx_size=%d", p_dcb->tx_size );
4665 BTA_HlSendData(p_dcb->mdl_handle, p_dcb->tx_size);
4666 } else {
4667 BTIF_TRACE_DEBUG("btif_hl_select_monitor_callback receive failed r=%d",r);
4668 BTA_HlDchClose(p_dcb->mdl_handle);
4669 }
4670 }
4671 }
4672 }
4673
4674 if (list_is_empty(soc_queue))
4675 BTIF_TRACE_DEBUG("btif_hl_select_monitor_queue is empty");
4676
4677 BTIF_TRACE_DEBUG("leaving %s",__FUNCTION__);
4678 }
4679
4680 /*******************************************************************************
4681 **
4682 ** Function btif_hl_select_wakeup_init
4683 **
4684 ** Description select loop wakup init
4685 **
4686 ** Returns int
4687 **
4688 *******************************************************************************/
btif_hl_select_wakeup_init(fd_set * set)4689 static inline int btif_hl_select_wakeup_init(fd_set* set){
4690 BTIF_TRACE_DEBUG("%s", __func__);
4691 if (signal_fds[0] == -1 && socketpair(AF_UNIX, SOCK_STREAM, 0, signal_fds) < 0)
4692 {
4693 BTIF_TRACE_ERROR("socketpair failed: %s", strerror(errno));
4694 return -1;
4695 }
4696
4697 BTIF_TRACE_DEBUG("btif_hl_select_wakeup_init signal_fds[0]=%d signal_fds[1]=%d",signal_fds[0], signal_fds[1] );
4698 FD_SET(signal_fds[0], set);
4699
4700 return signal_fds[0];
4701 }
4702
4703 /*******************************************************************************
4704 **
4705 ** Function btif_hl_select_wakeup
4706 **
4707 ** Description send a signal to wakupo the select loop
4708 **
4709 ** Returns int
4710 **
4711 *******************************************************************************/
btif_hl_select_wakeup(void)4712 static inline int btif_hl_select_wakeup(void){
4713 char sig_on = btif_hl_signal_select_wakeup;
4714
4715 BTIF_TRACE_DEBUG("%s", __func__);
4716
4717 ssize_t ret;
4718 OSI_NO_INTR(ret = send(signal_fds[1], &sig_on, sizeof(sig_on), 0));
4719
4720 return (int)ret;
4721 }
4722
4723 /*******************************************************************************
4724 **
4725 ** Function btif_hl_select_close_connected
4726 **
4727 ** Description send a signal to close a socket
4728 **
4729 ** Returns int
4730 **
4731 *******************************************************************************/
btif_hl_select_close_connected(void)4732 static inline int btif_hl_select_close_connected(void){
4733 char sig_on = btif_hl_signal_select_close_connected;
4734
4735 BTIF_TRACE_DEBUG("%s", __func__);
4736
4737 ssize_t ret;
4738 OSI_NO_INTR(ret = send(signal_fds[1], &sig_on, sizeof(sig_on), 0));
4739
4740 return (int)ret;
4741 }
4742
4743 /*******************************************************************************
4744 **
4745 ** Function btif_hl_close_select_thread
4746 **
4747 ** Description send signal to close the thread and then close all signal FDs
4748 **
4749 ** Returns int
4750 **
4751 *******************************************************************************/
btif_hl_close_select_thread(void)4752 static inline int btif_hl_close_select_thread(void)
4753 {
4754 ssize_t result = 0;
4755 char sig_on = btif_hl_signal_select_exit;
4756
4757 BTIF_TRACE_DEBUG("%", __func__);
4758
4759 OSI_NO_INTR(result = send(signal_fds[1], &sig_on, sizeof(sig_on), 0));
4760
4761 if (btif_is_enabled())
4762 {
4763 /* Wait for the select_thread_id to exit if BT is still enabled
4764 and only this profile getting cleaned up*/
4765 if (select_thread_id != -1) {
4766 pthread_join(select_thread_id, NULL);
4767 select_thread_id = -1;
4768 }
4769 }
4770 list_free(soc_queue);
4771 soc_queue = NULL;
4772
4773 return (int)result;
4774 }
4775
4776 /*******************************************************************************
4777 **
4778 ** Function btif_hl_select_wake_reset
4779 **
4780 ** Description clear the received signal for the select loop
4781 **
4782 ** Returns int
4783 **
4784 *******************************************************************************/
btif_hl_select_wake_reset(void)4785 static inline int btif_hl_select_wake_reset(void){
4786 char sig_recv = 0;
4787
4788 BTIF_TRACE_DEBUG("%s", __func__);
4789
4790 ssize_t r;
4791 OSI_NO_INTR(r = recv(signal_fds[0], &sig_recv, sizeof(sig_recv),
4792 MSG_WAITALL));
4793
4794 return (int)sig_recv;
4795 }
4796 /*******************************************************************************
4797 **
4798 ** Function btif_hl_select_wake_signaled
4799 **
4800 ** Description check whether a fd is set or not
4801 **
4802 ** Returns int
4803 **
4804 *******************************************************************************/
btif_hl_select_wake_signaled(fd_set * set)4805 static inline int btif_hl_select_wake_signaled(fd_set* set){
4806 BTIF_TRACE_DEBUG("btif_hl_select_wake_signaled");
4807 return FD_ISSET(signal_fds[0], set);
4808 }
4809 /*******************************************************************************
4810 **
4811 ** Function btif_hl_thread_cleanup
4812 **
4813 ** Description shut down and clean up the select loop
4814 **
4815 ** Returns void
4816 **
4817 *******************************************************************************/
btif_hl_thread_cleanup()4818 static void btif_hl_thread_cleanup(){
4819 if (listen_s != -1)
4820 close(listen_s);
4821 if (connected_s != -1)
4822 {
4823 shutdown(connected_s, SHUT_RDWR);
4824 close(connected_s);
4825 }
4826 listen_s = connected_s = -1;
4827 BTIF_TRACE_DEBUG("hl thread cleanup");
4828 }
4829 /*******************************************************************************
4830 **
4831 ** Function btif_hl_select_thread
4832 **
4833 ** Description the select loop
4834 **
4835 ** Returns void
4836 **
4837 *******************************************************************************/
btif_hl_select_thread(void * arg)4838 static void *btif_hl_select_thread(void *arg){
4839 fd_set org_set, curr_set;
4840 int r, max_curr_s, max_org_s;
4841 UNUSED(arg);
4842
4843 BTIF_TRACE_DEBUG("entered btif_hl_select_thread");
4844 FD_ZERO(&org_set);
4845 max_org_s = btif_hl_select_wakeup_init(&org_set);
4846 BTIF_TRACE_DEBUG("max_s=%d ", max_org_s);
4847
4848 for (;;)
4849 {
4850 r = 0;
4851 BTIF_TRACE_DEBUG("set curr_set = org_set ");
4852 curr_set = org_set;
4853 max_curr_s = max_org_s;
4854 int ret = select((max_curr_s + 1), &curr_set, NULL, NULL, NULL);
4855 BTIF_TRACE_DEBUG("select unblocked ret=%d", ret);
4856 if (ret == -1)
4857 {
4858 if (errno == EINTR)
4859 continue;
4860 BTIF_TRACE_DEBUG("select() ret -1, exit the thread");
4861 btif_hl_thread_cleanup();
4862 select_thread_id = -1;
4863 return 0;
4864 }
4865 else if (ret)
4866 {
4867 BTIF_TRACE_DEBUG("btif_hl_select_wake_signaled, signal ret=%d", ret);
4868 if (btif_hl_select_wake_signaled(&curr_set))
4869 {
4870 r = btif_hl_select_wake_reset();
4871 BTIF_TRACE_DEBUG("btif_hl_select_wake_signaled, signal:%d", r);
4872 if (r == btif_hl_signal_select_wakeup || r == btif_hl_signal_select_close_connected )
4873 {
4874 btif_hl_select_wakeup_callback(&org_set, r);
4875 }
4876 else if( r == btif_hl_signal_select_exit)
4877 {
4878 btif_hl_thread_cleanup();
4879 BTIF_TRACE_DEBUG("Exit hl_select_thread for btif_hl_signal_select_exit");
4880 return 0;
4881 }
4882 }
4883
4884 btif_hl_select_monitor_callback(&curr_set, &org_set);
4885 max_org_s = btif_hl_update_maxfd(max_org_s);
4886 }
4887 else
4888 BTIF_TRACE_DEBUG("no data, select ret: %d\n", ret);
4889 }
4890 BTIF_TRACE_DEBUG("leaving hl_select_thread");
4891 return 0;
4892 }
4893
4894 /*******************************************************************************
4895 **
4896 ** Function create_thread
4897 **
4898 ** Description creat a select loop
4899 **
4900 ** Returns pthread_t
4901 **
4902 *******************************************************************************/
create_thread(void * (* start_routine)(void *),void * arg)4903 static inline pthread_t create_thread(void *(*start_routine)(void *), void * arg){
4904 BTIF_TRACE_DEBUG("create_thread: entered");
4905 pthread_attr_t thread_attr;
4906
4907 pthread_attr_init(&thread_attr);
4908 pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_JOINABLE);
4909 pthread_t thread_id = -1;
4910 if ( pthread_create(&thread_id, &thread_attr, start_routine, arg)!=0 )
4911 {
4912 BTIF_TRACE_ERROR("pthread_create : %s", strerror(errno));
4913 return -1;
4914 }
4915 BTIF_TRACE_DEBUG("create_thread: thread created successfully");
4916 return thread_id;
4917 }
4918
4919 /*******************************************************************************
4920 **
4921 ** Function btif_hl_soc_thread_init
4922 **
4923 ** Description HL select loop init function.
4924 **
4925 ** Returns void
4926 **
4927 *******************************************************************************/
btif_hl_soc_thread_init(void)4928 void btif_hl_soc_thread_init(void){
4929 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
4930 soc_queue = list_new(NULL);
4931 if (soc_queue == NULL)
4932 LOG_ERROR(LOG_TAG, "%s unable to allocate resources for thread", __func__);
4933 select_thread_id = create_thread(btif_hl_select_thread, NULL);
4934 }
4935 /*******************************************************************************
4936 **
4937 ** Function btif_hl_load_mdl_config
4938 **
4939 ** Description load the MDL configuation from the application control block
4940 **
4941 ** Returns BOOLEAN
4942 **
4943 *******************************************************************************/
btif_hl_load_mdl_config(UINT8 app_id,UINT8 buffer_size,tBTA_HL_MDL_CFG * p_mdl_buf)4944 BOOLEAN btif_hl_load_mdl_config (UINT8 app_id, UINT8 buffer_size,
4945 tBTA_HL_MDL_CFG *p_mdl_buf ){
4946 UINT8 app_idx;
4947 BOOLEAN result = FALSE;
4948 btif_hl_app_cb_t *p_acb;
4949 tBTA_HL_MDL_CFG *p;
4950 int i;
4951 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
4952
4953 if (btif_hl_find_app_idx(app_id, &app_idx))
4954 {
4955 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
4956 for (i=0, p=p_mdl_buf; i<buffer_size; i++, p++)
4957 {
4958 memcpy(p, &p_acb->mdl_cfg[i].base, sizeof(tBTA_HL_MDL_CFG));
4959 }
4960 result = TRUE;
4961 }
4962
4963 BTIF_TRACE_DEBUG("result=%d", result);
4964 return result;
4965 }
4966