1 /******************************************************************************
2 *
3 * Copyright (C) 2003-2012 Broadcom Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 /******************************************************************************
20 *
21 * This file implements utility functions for the HeaLth device profile
22 * (HL).
23 *
24 ******************************************************************************/
25
26 #include <stdio.h>
27 #include <string.h>
28
29 #include "bt_target.h"
30 #if defined(HL_INCLUDED) && (HL_INCLUDED == TRUE)
31
32
33 #include "gki.h"
34 #include "utl.h"
35 #include "bd.h"
36 #include "bta_fs_api.h"
37 #include "bta_hl_int.h"
38 #include "bta_hl_co.h"
39 #include "mca_defs.h"
40 #include "mca_api.h"
41
42
43 /*******************************************************************************
44 **
45 ** Function bta_hl_set_ctrl_psm_for_dch
46 **
47 ** Description This function set the control PSM for the DCH setup
48 **
49 ** Returns BOOLEAN - TRUE - control PSM setting is successful
50 *******************************************************************************/
bta_hl_set_ctrl_psm_for_dch(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdl_idx,UINT16 ctrl_psm)51 BOOLEAN bta_hl_set_ctrl_psm_for_dch(UINT8 app_idx, UINT8 mcl_idx,
52 UINT8 mdl_idx, UINT16 ctrl_psm)
53 {
54 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
55 BOOLEAN success = TRUE, update_ctrl_psm = FALSE;
56
57 if (p_mcb->sdp.num_recs)
58 {
59 if (p_mcb->ctrl_psm != ctrl_psm)
60 {
61 /* can not use a different ctrl PSM than the current one*/
62 success = FALSE;
63 }
64 }
65 else
66 {
67 /* No SDP info control i.e. channel was opened by the peer */
68 update_ctrl_psm = TRUE;
69 }
70
71 if (success && update_ctrl_psm)
72 {
73 p_mcb->ctrl_psm = ctrl_psm;
74 }
75
76
77 #if BTA_HL_DEBUG == TRUE
78 if (!success)
79 {
80 APPL_TRACE_DEBUG4("bta_hl_set_ctrl_psm_for_dch num_recs=%d success=%d update_ctrl_psm=%d ctrl_psm=0x%x ",
81 p_mcb->sdp.num_recs, success, update_ctrl_psm, ctrl_psm );
82 }
83 #endif
84
85 return success;
86 }
87
88
89 /*******************************************************************************
90 **
91 ** Function bta_hl_find_sdp_idx_using_ctrl_psm
92 **
93 ** Description
94 **
95 ** Returns UINT8 pool_id
96 **
97 *******************************************************************************/
bta_hl_find_sdp_idx_using_ctrl_psm(tBTA_HL_SDP * p_sdp,UINT16 ctrl_psm,UINT8 * p_sdp_idx)98 BOOLEAN bta_hl_find_sdp_idx_using_ctrl_psm(tBTA_HL_SDP *p_sdp,
99 UINT16 ctrl_psm,
100 UINT8 *p_sdp_idx)
101 {
102 BOOLEAN found=FALSE;
103 tBTA_HL_SDP_REC *p_rec;
104 UINT8 i;
105
106 if (ctrl_psm != 0)
107 {
108 for (i=0; i<p_sdp->num_recs; i++)
109 {
110 p_rec = &p_sdp->sdp_rec[i];
111 if (p_rec->ctrl_psm == ctrl_psm)
112 {
113 *p_sdp_idx = i;
114 found = TRUE;
115 break;
116 }
117 }
118 }
119 else
120 {
121 *p_sdp_idx = 0;
122 found = TRUE;
123 }
124
125 #if BTA_HL_DEBUG == TRUE
126 if (!found)
127 {
128 APPL_TRACE_DEBUG3("bta_hl_find_sdp_idx_using_ctrl_psm found=%d sdp_idx=%d ctrl_psm=0x%x ",
129 found, *p_sdp_idx, ctrl_psm );
130 }
131 #endif
132 return found;
133 }
134
135 /*******************************************************************************
136 **
137 ** Function bta_hl_set_user_tx_pool_id
138 **
139 ** Description This function sets the user tx pool id
140 **
141 ** Returns UINT8 pool_id
142 **
143 *******************************************************************************/
144
bta_hl_set_user_tx_pool_id(UINT16 max_tx_size)145 UINT8 bta_hl_set_user_tx_pool_id(UINT16 max_tx_size)
146 {
147 UINT8 pool_id;
148
149 if (max_tx_size > GKI_get_pool_bufsize (OBX_FCR_TX_POOL_ID))
150 {
151 pool_id = BTA_HL_LRG_DATA_POOL_ID;
152 }
153 else
154 {
155 pool_id = L2CAP_DEFAULT_ERM_POOL_ID;
156 }
157
158 #if BTA_HL_DEBUG == TRUE
159 APPL_TRACE_DEBUG3("bta_hl_set_user_rx_pool_id pool_id=%d max_tx_size=%d default_ertm_pool_size=%d",
160 pool_id, max_tx_size, GKI_get_pool_bufsize (OBX_FCR_TX_POOL_ID));
161 #endif
162
163 return pool_id;
164 }
165
166 /*******************************************************************************
167 **
168 ** Function bta_hl_set_user_rx_pool_id
169 **
170 ** Description This function sets the user trx pool id
171 **
172 ** Returns UINT8 pool_id
173 **
174 *******************************************************************************/
175
bta_hl_set_user_rx_pool_id(UINT16 mtu)176 UINT8 bta_hl_set_user_rx_pool_id(UINT16 mtu)
177 {
178 UINT8 pool_id;
179
180 if (mtu > GKI_get_pool_bufsize (OBX_FCR_RX_POOL_ID))
181 {
182 pool_id = BTA_HL_LRG_DATA_POOL_ID;
183 }
184 else
185 {
186 pool_id = L2CAP_DEFAULT_ERM_POOL_ID;
187 }
188
189 #if BTA_HL_DEBUG == TRUE
190 APPL_TRACE_DEBUG3("bta_hl_set_user_rx_pool_id pool_id=%d mtu=%d default_ertm_pool_size=%d",
191 pool_id, mtu, GKI_get_pool_bufsize (OBX_FCR_RX_POOL_ID));
192 #endif
193
194 return pool_id;
195 }
196
197
198
199 /*******************************************************************************
200 **
201 ** Function bta_hl_set_tx_win_size
202 **
203 ** Description This function sets the tx window size
204 **
205 ** Returns UINT8 tx_win_size
206 **
207 *******************************************************************************/
bta_hl_set_tx_win_size(UINT16 mtu,UINT16 mps)208 UINT8 bta_hl_set_tx_win_size(UINT16 mtu, UINT16 mps)
209 {
210 UINT8 tx_win_size;
211
212 if (mtu <= mps)
213 {
214 tx_win_size =1;
215 }
216 else
217 {
218 if (mps > 0)
219 {
220 tx_win_size = (mtu/mps)+1;
221 }
222 else
223 {
224 APPL_TRACE_ERROR0("The MPS is zero");
225 tx_win_size = 10;
226 }
227 }
228
229 #if BTA_HL_DEBUG == TRUE
230 APPL_TRACE_DEBUG3("bta_hl_set_tx_win_size win_size=%d mtu=%d mps=%d",
231 tx_win_size, mtu, mps);
232 #endif
233 return tx_win_size;
234 }
235
236 /*******************************************************************************
237 **
238 ** Function bta_hl_set_mps
239 **
240 ** Description This function sets the MPS
241 **
242 ** Returns UINT16 MPS
243 **
244 *******************************************************************************/
bta_hl_set_mps(UINT16 mtu)245 UINT16 bta_hl_set_mps(UINT16 mtu)
246 {
247 UINT16 mps;
248 if (mtu > BTA_HL_L2C_MPS)
249 {
250 mps = BTA_HL_L2C_MPS;
251 }
252 else
253 {
254 mps = mtu;
255 }
256 #if BTA_HL_DEBUG == TRUE
257 APPL_TRACE_DEBUG2("bta_hl_set_mps mps=%d mtu=%d",
258 mps, mtu);
259 #endif
260 return mps;
261 }
262
263
264 /*******************************************************************************
265 **
266 ** Function bta_hl_clean_mdl_cb
267 **
268 ** Description This function clean up the specified MDL control block
269 **
270 ** Returns void
271 **
272 *******************************************************************************/
bta_hl_clean_mdl_cb(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdl_idx)273 void bta_hl_clean_mdl_cb(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx)
274 {
275 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
276 #if BTA_HL_DEBUG == TRUE
277 APPL_TRACE_DEBUG3("bta_hl_clean_mdl_cb app_idx=%d mcl_idx=%d mdl_idx=%d",
278 app_idx, mcl_idx, mdl_idx);
279 #endif
280 utl_freebuf((void **) &p_dcb->p_tx_pkt);
281 utl_freebuf((void **) &p_dcb->p_rx_pkt);
282 utl_freebuf((void **) &p_dcb->p_echo_tx_pkt);
283 utl_freebuf((void **) &p_dcb->p_echo_rx_pkt);
284
285 memset((void *)p_dcb, 0 , sizeof(tBTA_HL_MDL_CB));
286 }
287
288
289 /*******************************************************************************
290 **
291 ** Function bta_hl_get_buf
292 **
293 ** Description This function allocate a buffer based on the specified data size
294 **
295 ** Returns BT_HDR *.
296 **
297 *******************************************************************************/
bta_hl_get_buf(UINT16 data_size)298 BT_HDR * bta_hl_get_buf(UINT16 data_size)
299 {
300 BT_HDR *p_new;
301 UINT16 size = data_size + L2CAP_MIN_OFFSET + BT_HDR_SIZE;
302
303 if (size < GKI_MAX_BUF_SIZE)
304 {
305 p_new = (BT_HDR *)GKI_getbuf(size);
306 }
307 else
308 {
309 p_new = (BT_HDR *) GKI_getpoolbuf(BTA_HL_LRG_DATA_POOL_ID);
310 }
311
312 if (p_new)
313 {
314 p_new->len = data_size;
315 p_new->offset = L2CAP_MIN_OFFSET;
316 }
317
318 return p_new;
319 }
320
321 /*******************************************************************************
322 **
323 ** Function bta_hl_find_service_in_db
324 **
325 ** Description This function check the specified service class(es) can be find in
326 ** the received SDP database
327 **
328 ** Returns BOOLEAN TRUE - found
329 ** FALSE - not found
330 **
331 *******************************************************************************/
bta_hl_find_service_in_db(UINT8 app_idx,UINT8 mcl_idx,UINT16 service_uuid,tSDP_DISC_REC ** pp_rec)332 BOOLEAN bta_hl_find_service_in_db( UINT8 app_idx, UINT8 mcl_idx,
333 UINT16 service_uuid,
334 tSDP_DISC_REC **pp_rec )
335 {
336 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
337 BOOLEAN found = TRUE;
338
339 switch (service_uuid)
340 {
341 case UUID_SERVCLASS_HDP_SINK:
342 case UUID_SERVCLASS_HDP_SOURCE:
343 if ((*pp_rec = SDP_FindServiceInDb(p_mcb->p_db, service_uuid,
344 *pp_rec)) == NULL)
345 {
346 found = FALSE;
347 }
348 break;
349 default:
350 if (((*pp_rec = bta_hl_find_sink_or_src_srv_class_in_db(p_mcb->p_db,
351 *pp_rec)) == NULL))
352 {
353 found = FALSE;
354 }
355 break;
356 }
357 return found;
358 }
359
360 /*******************************************************************************
361 **
362 ** Function bta_hl_get_service_uuids
363 **
364 **
365 ** Description This function finds the service class(es) for both CCH and DCH oeprations
366 **
367 ** Returns UINT16 - service_id
368 ** if service_uuid = 0xFFFF then it means service uuid
369 ** can be either Sink or Source
370 **
371 *******************************************************************************/
bta_hl_get_service_uuids(UINT8 sdp_oper,UINT8 app_idx,UINT8 mcl_idx,UINT8 mdl_idx)372 UINT16 bta_hl_get_service_uuids(UINT8 sdp_oper, UINT8 app_idx, UINT8 mcl_idx,
373 UINT8 mdl_idx )
374 {
375 tBTA_HL_MDL_CB *p_dcb;
376 UINT16 service_uuid = 0xFFFF; /* both Sink and Source */
377
378 switch (sdp_oper)
379 {
380
381 case BTA_HL_SDP_OP_DCH_OPEN_INIT:
382 case BTA_HL_SDP_OP_DCH_RECONNECT_INIT:
383 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
384 if (p_dcb->local_mdep_id != BTA_HL_ECHO_TEST_MDEP_ID)
385 {
386 if (p_dcb->peer_mdep_role == BTA_HL_MDEP_ROLE_SINK)
387 {
388 service_uuid = UUID_SERVCLASS_HDP_SINK;
389 }
390 else
391 {
392 service_uuid = UUID_SERVCLASS_HDP_SOURCE;
393 }
394 }
395 break;
396 case BTA_HL_SDP_OP_CCH_INIT:
397 default:
398 /* use default that is both Sink and Source */
399 break;
400 }
401 #if BTA_HL_DEBUG == TRUE
402 APPL_TRACE_DEBUG1("bta_hl_get_service_uuids service_uuid=0x%x",service_uuid );
403 #endif
404 return service_uuid;
405 }
406
407 /*******************************************************************************
408 **
409 ** Function bta_hl_find_echo_cfg_rsp
410 **
411 **
412 ** Description This function finds the configuration response for the echo test
413 **
414 ** Returns BOOLEAN - TRUE found
415 ** FALSE not found
416 **
417 *******************************************************************************/
bta_hl_find_echo_cfg_rsp(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdep_idx,UINT8 cfg,UINT8 * p_cfg_rsp)418 BOOLEAN bta_hl_find_echo_cfg_rsp(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdep_idx, UINT8 cfg,
419 UINT8 *p_cfg_rsp)
420 {
421 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
422 tBTA_HL_MDEP *p_mdep= &p_acb->sup_feature.mdep[mdep_idx];
423 BOOLEAN status =TRUE;
424
425 if (p_mdep->mdep_id == BTA_HL_ECHO_TEST_MDEP_ID)
426 {
427 if ((cfg == BTA_HL_DCH_CFG_RELIABLE) || (cfg == BTA_HL_DCH_CFG_STREAMING))
428 {
429 *p_cfg_rsp = cfg;
430 }
431 else if (cfg == BTA_HL_DCH_CFG_NO_PREF )
432 {
433 *p_cfg_rsp = BTA_HL_DEFAULT_ECHO_TEST_SRC_DCH_CFG;
434 }
435 else
436 {
437 status = FALSE;
438 APPL_TRACE_ERROR0("Inavlid echo cfg value");
439 }
440 return status;
441 }
442
443 #if BTA_HL_DEBUG == TRUE
444 if (!status)
445 {
446 APPL_TRACE_DEBUG4("bta_hl_find_echo_cfg_rsp status=failed app_idx=%d mcl_idx=%d mdep_idx=%d cfg=%d",
447 app_idx, mcl_idx, mdep_idx, cfg);
448 }
449 #endif
450
451 return status;
452 }
453
454 /*******************************************************************************
455 **
456 ** Function bta_hl_validate_dch_cfg
457 **
458 ** Description This function validate the DCH configuration
459 **
460 ** Returns BOOLEAN - TRUE cfg is valid
461 ** FALSE not valid
462 **
463 *******************************************************************************/
bta_hl_validate_cfg(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdl_idx,UINT8 cfg)464 BOOLEAN bta_hl_validate_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
465 UINT8 cfg)
466 {
467 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
468 BOOLEAN is_valid =FALSE;
469
470
471 if (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx) &&
472 (cfg != BTA_HL_DCH_CFG_RELIABLE))
473 {
474 APPL_TRACE_ERROR0("the first DCH should be a reliable channel");
475 return is_valid;
476 }
477
478 switch (p_dcb->local_cfg)
479 {
480 case BTA_HL_DCH_CFG_NO_PREF:
481
482 if ((cfg == BTA_HL_DCH_CFG_RELIABLE) || (cfg == BTA_HL_DCH_CFG_STREAMING))
483 {
484 is_valid = TRUE;
485 }
486 break;
487 case BTA_HL_DCH_CFG_RELIABLE:
488 case BTA_HL_DCH_CFG_STREAMING:
489 if (p_dcb->local_cfg == cfg )
490 {
491 is_valid = TRUE;
492 }
493 break;
494 default:
495 break;
496 }
497
498 #if BTA_HL_DEBUG == TRUE
499 if (!is_valid)
500 {
501 APPL_TRACE_DEBUG2("bta_hl_validate_dch_open_cfg is_valid=%d, cfg=%d", is_valid, cfg );
502 }
503 #endif
504 return is_valid;
505 }
506
507 /*******************************************************************************
508 **
509 ** Function bta_hl_find_cch_cb_indexes
510 **
511 ** Description This function finds the indexes needed for the CCH state machine
512 **
513 ** Returns BOOLEAN - TRUE found
514 ** FALSE not found
515 **
516 *******************************************************************************/
bta_hl_find_cch_cb_indexes(tBTA_HL_DATA * p_msg,UINT8 * p_app_idx,UINT8 * p_mcl_idx)517 BOOLEAN bta_hl_find_cch_cb_indexes(tBTA_HL_DATA *p_msg,
518 UINT8 *p_app_idx,
519 UINT8 *p_mcl_idx)
520 {
521 BOOLEAN found = FALSE;
522 tBTA_HL_MCL_CB *p_mcb;
523 UINT8 app_idx = 0, mcl_idx = 0;
524
525 switch (p_msg->hdr.event)
526 {
527 case BTA_HL_CCH_SDP_OK_EVT:
528 case BTA_HL_CCH_SDP_FAIL_EVT:
529 app_idx = p_msg->cch_sdp.app_idx;
530 mcl_idx = p_msg->cch_sdp.mcl_idx;
531 found = TRUE;
532 break;
533
534 case BTA_HL_MCA_CONNECT_IND_EVT:
535
536 if (bta_hl_find_app_idx_using_handle(p_msg->mca_evt.app_handle, &app_idx))
537 {
538 if (bta_hl_find_mcl_idx(app_idx, p_msg->mca_evt.mca_data.connect_ind.bd_addr, &mcl_idx))
539 {
540 /* local initiated */
541 found = TRUE;
542 }
543 else if (!bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx)&&
544 bta_hl_find_avail_mcl_idx(app_idx, &mcl_idx))
545 {
546 /* remote initiated */
547 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
548 p_mcb->in_use = TRUE;
549 p_mcb->cch_oper = BTA_HL_CCH_OP_REMOTE_OPEN;
550 found = TRUE;
551 }
552 }
553 break;
554
555 case BTA_HL_MCA_DISCONNECT_IND_EVT:
556
557 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx))
558 {
559 found = TRUE;
560 }
561 else if (bta_hl_find_app_idx_using_handle(p_msg->mca_evt.app_handle, &app_idx) &&
562 bta_hl_find_mcl_idx(app_idx, p_msg->mca_evt.mca_data.disconnect_ind.bd_addr, &mcl_idx))
563 {
564 found = TRUE;
565 }
566
567 if (found)
568 {
569 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
570 if ((p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_CLOSE) && (p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_OPEN) )
571 {
572 p_mcb->cch_oper = BTA_HL_CCH_OP_REMOTE_CLOSE;
573 }
574 }
575 break;
576
577 case BTA_HL_MCA_RSP_TOUT_IND_EVT:
578
579 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx))
580 {
581 found = TRUE;
582 }
583
584 if (found)
585 {
586 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
587 if ((p_mcb->cch_oper != BTA_HL_CCH_OP_REMOTE_CLOSE) && (p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_OPEN))
588 {
589 p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_CLOSE;
590 }
591 }
592 break;
593 default:
594 break;
595 }
596
597
598 if (found)
599 {
600 *p_app_idx = app_idx;
601 *p_mcl_idx = mcl_idx;
602 }
603
604 #if BTA_HL_DEBUG == TRUE
605 if (!found)
606 {
607 APPL_TRACE_DEBUG4("bta_hl_find_cch_cb_indexes event=%s found=%d app_idx=%d mcl_idx=%d",
608 bta_hl_evt_code(p_msg->hdr.event), found, app_idx, mcl_idx);
609 }
610 #endif
611
612 return found;
613 }
614
615 /*******************************************************************************
616 **
617 ** Function bta_hl_find_dch_cb_indexes
618 **
619 ** Description This function finds the indexes needed for the DCH state machine
620 **
621 ** Returns BOOLEAN - TRUE found
622 ** FALSE not found
623 **
624 *******************************************************************************/
bta_hl_find_dch_cb_indexes(tBTA_HL_DATA * p_msg,UINT8 * p_app_idx,UINT8 * p_mcl_idx,UINT8 * p_mdl_idx)625 BOOLEAN bta_hl_find_dch_cb_indexes(tBTA_HL_DATA *p_msg,
626 UINT8 *p_app_idx,
627 UINT8 *p_mcl_idx,
628 UINT8 *p_mdl_idx)
629 {
630 BOOLEAN found = FALSE;
631 tBTA_HL_MCL_CB *p_mcb;
632 UINT8 app_idx = 0, mcl_idx = 0, mdl_idx = 0;
633
634 switch (p_msg->hdr.event)
635 {
636 case BTA_HL_MCA_CREATE_CFM_EVT:
637 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
638 bta_hl_find_mdl_idx( app_idx, mcl_idx, p_msg->mca_evt.mca_data.create_cfm.mdl_id, &mdl_idx))
639 {
640 found = TRUE;
641 }
642 break;
643
644 case BTA_HL_MCA_CREATE_IND_EVT:
645 case BTA_HL_MCA_RECONNECT_IND_EVT:
646 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
647 bta_hl_find_avail_mdl_idx( app_idx, mcl_idx, &mdl_idx))
648 {
649 found = TRUE;
650 }
651 break;
652
653 case BTA_HL_MCA_OPEN_CFM_EVT:
654 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
655 bta_hl_find_mdl_idx( app_idx, mcl_idx, p_msg->mca_evt.mca_data.open_cfm.mdl_id, &mdl_idx))
656 {
657 found = TRUE;
658 }
659 break;
660
661 case BTA_HL_MCA_OPEN_IND_EVT:
662 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
663 bta_hl_find_mdl_idx( app_idx, mcl_idx, p_msg->mca_evt.mca_data.open_ind.mdl_id, &mdl_idx))
664 {
665 found = TRUE;
666 }
667 break;
668
669 case BTA_HL_MCA_CLOSE_CFM_EVT:
670
671 if (bta_hl_find_mdl_idx_using_handle((tBTA_HL_MDL_HANDLE)p_msg->mca_evt.mca_data.close_cfm.mdl,
672 &app_idx, &mcl_idx, &mdl_idx))
673 {
674 found = TRUE;
675 }
676 break;
677 case BTA_HL_MCA_CLOSE_IND_EVT:
678
679 if (bta_hl_find_mdl_idx_using_handle((tBTA_HL_MDL_HANDLE)p_msg->mca_evt.mca_data.close_ind.mdl,
680 &app_idx, &mcl_idx, &mdl_idx))
681 {
682 found = TRUE;
683 }
684 break;
685 case BTA_HL_API_SEND_DATA_EVT:
686
687 if (bta_hl_find_mdl_idx_using_handle(p_msg->api_send_data.mdl_handle,
688 &app_idx, &mcl_idx, &mdl_idx ))
689 {
690 found = TRUE;
691 }
692
693 break;
694
695 case BTA_HL_MCA_CONG_CHG_EVT:
696
697 if (bta_hl_find_mdl_idx_using_handle((tBTA_HL_MDL_HANDLE)p_msg->mca_evt.mca_data.cong_chg.mdl,
698 &app_idx, &mcl_idx, &mdl_idx ))
699 {
700 found = TRUE;
701 }
702
703 break;
704
705 case BTA_HL_MCA_RCV_DATA_EVT:
706 app_idx = p_msg->mca_rcv_data_evt.app_idx;
707 mcl_idx = p_msg->mca_rcv_data_evt.mcl_idx;
708 mdl_idx = p_msg->mca_rcv_data_evt.mdl_idx;
709 found = TRUE;
710 break;
711 case BTA_HL_DCH_RECONNECT_EVT:
712 case BTA_HL_DCH_OPEN_EVT:
713 case BTA_HL_DCH_ECHO_TEST_EVT:
714 case BTA_HL_DCH_SDP_FAIL_EVT:
715 app_idx = p_msg->dch_sdp.app_idx;
716 mcl_idx = p_msg->dch_sdp.mcl_idx;
717 mdl_idx = p_msg->dch_sdp.mdl_idx;
718 found = TRUE;
719 break;
720 case BTA_HL_MCA_RECONNECT_CFM_EVT:
721 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
722 bta_hl_find_mdl_idx( app_idx, mcl_idx, p_msg->mca_evt.mca_data.reconnect_cfm.mdl_id, &mdl_idx))
723 {
724 found = TRUE;
725 }
726 break;
727
728
729 case BTA_HL_API_DCH_CREATE_RSP_EVT:
730 if (bta_hl_find_mcl_idx_using_handle(p_msg->api_dch_create_rsp.mcl_handle, &app_idx, &mcl_idx)&&
731 bta_hl_find_mdl_idx( app_idx, mcl_idx,p_msg->api_dch_create_rsp.mdl_id, &mdl_idx))
732 {
733 found = TRUE;
734 }
735 break;
736 case BTA_HL_MCA_ABORT_IND_EVT:
737 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
738 bta_hl_find_mdl_idx( app_idx, mcl_idx,p_msg->mca_evt.mca_data.abort_ind.mdl_id, &mdl_idx))
739 {
740 found = TRUE;
741 }
742 break;
743 case BTA_HL_MCA_ABORT_CFM_EVT:
744 if (bta_hl_find_mcl_idx_using_handle(p_msg->mca_evt.mcl_handle, &app_idx, &mcl_idx) &&
745 bta_hl_find_mdl_idx( app_idx, mcl_idx, p_msg->mca_evt.mca_data.abort_cfm.mdl_id, &mdl_idx))
746 {
747 found = TRUE;
748 }
749 break;
750 case BTA_HL_CI_GET_TX_DATA_EVT:
751 case BTA_HL_CI_PUT_RX_DATA_EVT:
752 if (bta_hl_find_mdl_idx_using_handle(p_msg->ci_get_put_data.mdl_handle, &app_idx, &mcl_idx, &mdl_idx))
753 {
754 found = TRUE;
755 }
756 break;
757 case BTA_HL_CI_GET_ECHO_DATA_EVT:
758 case BTA_HL_CI_PUT_ECHO_DATA_EVT:
759 if (bta_hl_find_mcl_idx_using_handle(p_msg->ci_get_put_echo_data.mcl_handle, &app_idx, &mcl_idx))
760 {
761 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
762 mdl_idx = p_mcb->echo_mdl_idx;
763 found = TRUE;
764 }
765 break;
766
767 default:
768 break;
769
770 }
771
772 if (found)
773 {
774 *p_app_idx = app_idx;
775 *p_mcl_idx = mcl_idx;
776 *p_mdl_idx = mdl_idx;
777 }
778 #if BTA_HL_DEBUG == TRUE
779 if (!found)
780 {
781 APPL_TRACE_DEBUG5("bta_hl_find_dch_cb_indexes event=%s found=%d app_idx=%d mcl_idx=%d mdl_idx=%d",
782 bta_hl_evt_code(p_msg->hdr.event), found, *p_app_idx, *p_mcl_idx, *p_mdl_idx );
783 }
784 #endif
785
786 return found;
787 }
788
789 /*******************************************************************************
790 **
791 ** Function bta_hl_allocate_mdl_id
792 **
793 ** Description This function allocates a MDL ID
794 **
795 ** Returns UINT16 - MDL ID
796 **
797 *******************************************************************************/
bta_hl_allocate_mdl_id(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdl_idx)798 UINT16 bta_hl_allocate_mdl_id(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx )
799 {
800 UINT16 mdl_id=0;
801 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
802 BOOLEAN duplicate_id;
803 UINT8 i, mdl_cfg_idx;
804
805 do
806 {
807 duplicate_id = FALSE;
808 mdl_id = ((mdl_id+1) & 0xFEFF);
809 /* check mdl_ids that are used for the current conenctions */
810 for (i=0; i< BTA_HL_NUM_MDLS_PER_MCL; i++)
811 {
812 if (p_mcb->mdl[i].in_use &&
813 (i != mdl_idx) &&
814 (p_mcb->mdl[i].mdl_id == mdl_id) )
815 {
816 duplicate_id = TRUE;
817 break;
818 }
819 }
820
821 if (duplicate_id)
822 {
823 /* start from the beginning to get another MDL value*/
824 continue;
825 }
826 else
827 {
828 /* check mdl_ids that are stored in the persistent memory */
829 if (bta_hl_find_mdl_cfg_idx(app_idx,mcl_idx, mdl_id, &mdl_cfg_idx))
830 {
831 duplicate_id = TRUE;
832 }
833 else
834 {
835 /* found a new MDL value */
836 break;
837 }
838 }
839
840 }while (TRUE);
841
842 #if BTA_HL_DEBUG == TRUE
843 APPL_TRACE_DEBUG1("bta_hl_allocate_mdl OK mdl_id=%d", mdl_id);
844 #endif
845 return mdl_id;
846 }
847 /*******************************************************************************
848 **
849 ** Function bta_hl_find_mdl_idx
850 **
851 ** Description This function finds the MDL index based on mdl_id
852 **
853 ** Returns BOOLEAN TRUE-found
854 **
855 *******************************************************************************/
bta_hl_find_mdl_idx(UINT8 app_idx,UINT8 mcl_idx,UINT16 mdl_id,UINT8 * p_mdl_idx)856 BOOLEAN bta_hl_find_mdl_idx(UINT8 app_idx, UINT8 mcl_idx, UINT16 mdl_id,
857 UINT8 *p_mdl_idx)
858 {
859 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
860 BOOLEAN found=FALSE;
861 UINT8 i;
862
863 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
864 {
865 if (p_mcb->mdl[i].in_use &&
866 (mdl_id !=0) &&
867 (p_mcb->mdl[i].mdl_id== mdl_id))
868 {
869 found = TRUE;
870 *p_mdl_idx = i;
871 break;
872 }
873 }
874
875 #if BTA_HL_DEBUG == TRUE
876 if (!found)
877 {
878 APPL_TRACE_DEBUG3("bta_hl_find_mdl_idx found=%d mdl_id=%d mdl_idx=%d ",
879 found, mdl_id, i);
880 }
881 #endif
882
883 return found;
884 }
885
886 /*******************************************************************************
887 **
888 ** Function bta_hl_find_an_active_mdl_idx
889 **
890 ** Description This function finds an active MDL
891 **
892 ** Returns BOOLEAN TRUE-found
893 **
894 *******************************************************************************/
bta_hl_find_an_active_mdl_idx(UINT8 app_idx,UINT8 mcl_idx,UINT8 * p_mdl_idx)895 BOOLEAN bta_hl_find_an_active_mdl_idx(UINT8 app_idx, UINT8 mcl_idx,
896 UINT8 *p_mdl_idx)
897 {
898 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
899 BOOLEAN found=FALSE;
900 UINT8 i;
901
902 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
903 {
904 if (p_mcb->mdl[i].in_use &&
905 (p_mcb->mdl[i].dch_state == BTA_HL_DCH_OPEN_ST))
906 {
907 found = TRUE;
908 *p_mdl_idx = i;
909 break;
910 }
911 }
912
913 #if BTA_HL_DEBUG == TRUE
914 if (found)
915 {
916 APPL_TRACE_DEBUG4("bta_hl_find_an_opened_mdl_idx found=%d app_idx=%d mcl_idx=%d mdl_idx=%d",
917 found, app_idx, mcl_idx, i);
918 }
919 #endif
920
921 return found;
922 }
923
924 /*******************************************************************************
925 **
926 ** Function bta_hl_find_dch_setup_mdl_idx
927 **
928 ** Description This function finds a MDL which in the DCH setup state
929 **
930 ** Returns BOOLEAN TRUE-found
931 **
932 *******************************************************************************/
bta_hl_find_dch_setup_mdl_idx(UINT8 app_idx,UINT8 mcl_idx,UINT8 * p_mdl_idx)933 BOOLEAN bta_hl_find_dch_setup_mdl_idx(UINT8 app_idx, UINT8 mcl_idx,
934 UINT8 *p_mdl_idx)
935 {
936 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
937 BOOLEAN found=FALSE;
938 UINT8 i;
939
940 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
941 {
942 if (p_mcb->mdl[i].in_use &&
943 (p_mcb->mdl[i].dch_state == BTA_HL_DCH_OPENING_ST))
944 {
945 found = TRUE;
946 *p_mdl_idx = i;
947 break;
948 }
949 }
950
951 #if BTA_HL_DEBUG == TRUE
952 if (found)
953 {
954 APPL_TRACE_DEBUG4("bta_hl_find_dch_setup_mdl_idx found=%d app_idx=%d mcl_idx=%d mdl_idx=%d",
955 found, app_idx, mcl_idx, i);
956 }
957 #endif
958
959 return found;
960 }
961
962 /*******************************************************************************
963 **
964 ** Function bta_hl_find_an_in_use_mcl_idx
965 **
966 ** Description This function finds an in-use MCL control block index
967 **
968 ** Returns BOOLEAN TRUE-found
969 **
970 *******************************************************************************/
bta_hl_find_an_in_use_mcl_idx(UINT8 app_idx,UINT8 * p_mcl_idx)971 BOOLEAN bta_hl_find_an_in_use_mcl_idx(UINT8 app_idx,
972 UINT8 *p_mcl_idx)
973 {
974 tBTA_HL_MCL_CB *p_mcb;
975 BOOLEAN found=FALSE;
976 UINT8 i;
977
978 for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
979 {
980 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, i);
981 if (p_mcb->in_use &&
982 (p_mcb->cch_state != BTA_HL_CCH_IDLE_ST))
983 {
984 found = TRUE;
985 *p_mcl_idx = i;
986 break;
987 }
988 }
989
990 #if BTA_HL_DEBUG == TRUE
991 if (found)
992 {
993 APPL_TRACE_DEBUG3("bta_hl_find_an_in_use_mcl_idx found=%d app_idx=%d mcl_idx=%d ",
994 found, app_idx, i);
995 }
996 #endif
997
998 return found;
999 }
1000
1001
1002 /*******************************************************************************
1003 **
1004 ** Function bta_hl_find_an_in_use_app_idx
1005 **
1006 ** Description This function finds an in-use application control block index
1007 **
1008 ** Returns BOOLEAN TRUE-found
1009 **
1010 *******************************************************************************/
bta_hl_find_an_in_use_app_idx(UINT8 * p_app_idx)1011 BOOLEAN bta_hl_find_an_in_use_app_idx(UINT8 *p_app_idx)
1012 {
1013 tBTA_HL_APP_CB *p_acb ;
1014 BOOLEAN found=FALSE;
1015 UINT8 i;
1016
1017 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1018 {
1019 p_acb = BTA_HL_GET_APP_CB_PTR(i);
1020 if (p_acb->in_use)
1021 {
1022 found = TRUE;
1023 *p_app_idx = i;
1024 break;
1025 }
1026 }
1027
1028 #if BTA_HL_DEBUG == TRUE
1029 if (found)
1030 {
1031 APPL_TRACE_DEBUG2("bta_hl_find_an_in_use_app_idx found=%d app_idx=%d ",
1032 found, i);
1033 }
1034 #endif
1035
1036 return found;
1037 }
1038 /*******************************************************************************
1039 **
1040 ** Function bta_hl_find_app_idx
1041 **
1042 ** Description This function finds the application control block index based on
1043 ** the application ID
1044 **
1045 ** Returns BOOLEAN TRUE-found
1046 **
1047 *******************************************************************************/
bta_hl_find_app_idx(UINT8 app_id,UINT8 * p_app_idx)1048 BOOLEAN bta_hl_find_app_idx(UINT8 app_id, UINT8 *p_app_idx)
1049 {
1050 BOOLEAN found=FALSE;
1051 UINT8 i;
1052
1053 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1054 {
1055 if (bta_hl_cb.acb[i].in_use &&
1056 (bta_hl_cb.acb[i].app_id == app_id))
1057 {
1058 found = TRUE;
1059 *p_app_idx = i;
1060 break;
1061 }
1062 }
1063
1064 #if BTA_HL_DEBUG == TRUE
1065 APPL_TRACE_DEBUG3("bta_hl_find_app_idx found=%d app_id=%d idx=%d ",
1066 found, app_id, i);
1067 #endif
1068
1069 return found;
1070 }
1071
1072
1073 /*******************************************************************************
1074 **
1075 ** Function bta_hl_find_app_idx_using_handle
1076 **
1077 ** Description This function finds the application control block index based on
1078 ** the application handle
1079 **
1080 ** Returns BOOLEAN TRUE-found
1081 **
1082 *******************************************************************************/
bta_hl_find_app_idx_using_handle(tBTA_HL_APP_HANDLE app_handle,UINT8 * p_app_idx)1083 BOOLEAN bta_hl_find_app_idx_using_handle(tBTA_HL_APP_HANDLE app_handle,
1084 UINT8 *p_app_idx)
1085 {
1086 BOOLEAN found=FALSE;
1087 UINT8 i;
1088
1089 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1090 {
1091 if (bta_hl_cb.acb[i].in_use &&
1092 (bta_hl_cb.acb[i].app_handle == app_handle))
1093 {
1094 found = TRUE;
1095 *p_app_idx = i;
1096 break;
1097 }
1098 }
1099
1100 #if BTA_HL_DEBUG == TRUE
1101 if (!found)
1102 {
1103 APPL_TRACE_DEBUG3("bta_hl_find_app_idx_using_mca_handle status=%d handle=%d app_idx=%d ",
1104 found, app_handle , i);
1105 }
1106 #endif
1107
1108 return found;
1109 }
1110
1111
1112 /*******************************************************************************
1113 **
1114 ** Function bta_hl_find_mcl_idx_using_handle
1115 **
1116 ** Description This function finds the MCL control block index based on
1117 ** the MCL handle
1118 **
1119 ** Returns BOOLEAN TRUE-found
1120 **
1121 *******************************************************************************/
bta_hl_find_mcl_idx_using_handle(tBTA_HL_MCL_HANDLE mcl_handle,UINT8 * p_app_idx,UINT8 * p_mcl_idx)1122 BOOLEAN bta_hl_find_mcl_idx_using_handle( tBTA_HL_MCL_HANDLE mcl_handle,
1123 UINT8 *p_app_idx, UINT8 *p_mcl_idx)
1124 {
1125 tBTA_HL_APP_CB *p_acb;
1126 BOOLEAN found=FALSE;
1127 UINT8 i = 0,j = 0;
1128
1129 for (i=0; i<BTA_HL_NUM_APPS; i++)
1130 {
1131 p_acb = BTA_HL_GET_APP_CB_PTR(i);
1132 if (p_acb->in_use)
1133 {
1134 for (j=0; j < BTA_HL_NUM_MCLS ; j++)
1135 {
1136 if ( p_acb->mcb[j].mcl_handle == mcl_handle )
1137 {
1138 found = TRUE;
1139 *p_app_idx = i;
1140 *p_mcl_idx = j;
1141 break;
1142 }
1143 }
1144 }
1145 }
1146
1147 #if BTA_HL_DEBUG == TRUE
1148 if (!found)
1149 {
1150 APPL_TRACE_DEBUG3("bta_hl_find_mcl_idx_using_handle found=%d app_idx=%d mcl_idx=%d",
1151 found, i, j);
1152 }
1153 #endif
1154 return found;
1155 }
1156
1157 /*******************************************************************************
1158 **
1159 ** Function bta_hl_find_mcl_idx
1160 **
1161 ** Description This function finds the MCL control block index based on
1162 ** the peer BD address
1163 **
1164 ** Returns BOOLEAN TRUE-found
1165 **
1166 *******************************************************************************/
bta_hl_find_mcl_idx(UINT8 app_idx,BD_ADDR p_bd_addr,UINT8 * p_mcl_idx)1167 BOOLEAN bta_hl_find_mcl_idx(UINT8 app_idx, BD_ADDR p_bd_addr, UINT8 *p_mcl_idx)
1168 {
1169 BOOLEAN found=FALSE;
1170 UINT8 i;
1171 tBTA_HL_MCL_CB *p_mcb;
1172
1173 for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
1174 {
1175 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, i);
1176
1177 if (bta_hl_cb.acb[app_idx].mcb[i].in_use &&
1178 (!memcmp (bta_hl_cb.acb[app_idx].mcb[i].bd_addr, p_bd_addr, BD_ADDR_LEN)))
1179 {
1180 found = TRUE;
1181 *p_mcl_idx = i;
1182 break;
1183 }
1184 }
1185
1186 #if BTA_HL_DEBUG == TRUE
1187 if (!found)
1188 {
1189 APPL_TRACE_DEBUG2("bta_hl_find_mcl_idx found=%d idx=%d",
1190 found, i);
1191 }
1192 #endif
1193 return found;
1194 }
1195
1196
1197
1198 /*******************************************************************************
1199 **
1200 ** Function bta_hl_find_mdl_idx_using_handle
1201 **
1202 ** Description This function finds the MDL control block index based on
1203 ** the MDL handle
1204 **
1205 ** Returns BOOLEAN TRUE-found
1206 **
1207 *******************************************************************************/
bta_hl_find_mdl_idx_using_handle(tBTA_HL_MDL_HANDLE mdl_handle,UINT8 * p_app_idx,UINT8 * p_mcl_idx,UINT8 * p_mdl_idx)1208 BOOLEAN bta_hl_find_mdl_idx_using_handle(tBTA_HL_MDL_HANDLE mdl_handle,
1209 UINT8 *p_app_idx,UINT8 *p_mcl_idx,
1210 UINT8 *p_mdl_idx)
1211 {
1212 tBTA_HL_APP_CB *p_acb;
1213 tBTA_HL_MCL_CB *p_mcb;
1214 tBTA_HL_MDL_CB *p_dcb;
1215 BOOLEAN found=FALSE;
1216 UINT8 i,j,k;
1217
1218 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
1219 {
1220 p_acb = BTA_HL_GET_APP_CB_PTR(i);
1221 if (p_acb->in_use)
1222 {
1223 for (j=0; j< BTA_HL_NUM_MCLS; j++)
1224 {
1225 p_mcb = BTA_HL_GET_MCL_CB_PTR(i,j);
1226 if (p_mcb->in_use)
1227 {
1228 for (k=0; k< BTA_HL_NUM_MDLS_PER_MCL; k++)
1229 {
1230 p_dcb = BTA_HL_GET_MDL_CB_PTR(i,j,k);
1231 if (p_dcb->in_use)
1232 {
1233 if (p_dcb->mdl_handle == mdl_handle)
1234 {
1235 found = TRUE;
1236 *p_app_idx = i;
1237 *p_mcl_idx =j;
1238 *p_mdl_idx = k;
1239 break;
1240 }
1241 }
1242 }
1243 }
1244 }
1245 }
1246 }
1247
1248
1249 #if BTA_HL_DEBUG == TRUE
1250 if (!found)
1251 {
1252 APPL_TRACE_DEBUG2("bta_hl_find_mdl_idx_using_handle found=%d mdl_handle=%d ",
1253 found, mdl_handle);
1254 }
1255 #endif
1256 return found;
1257 }
1258 /*******************************************************************************
1259 **
1260 ** Function bta_hl_is_the_first_reliable_existed
1261 **
1262 ** Description This function checks whether the first reliable DCH channel
1263 ** has been setup on the MCL or not
1264 **
1265 ** Returns BOOLEAN - TRUE exist
1266 ** FALSE does not exist
1267 **
1268 *******************************************************************************/
bta_hl_is_the_first_reliable_existed(UINT8 app_idx,UINT8 mcl_idx)1269 BOOLEAN bta_hl_is_the_first_reliable_existed(UINT8 app_idx, UINT8 mcl_idx )
1270 {
1271 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1272 BOOLEAN is_existed =FALSE;
1273 UINT8 i ;
1274
1275 for (i=0; i< BTA_HL_NUM_MDLS_PER_MCL; i++)
1276 {
1277 if (p_mcb->mdl[i].in_use && p_mcb->mdl[i].is_the_first_reliable)
1278 {
1279 is_existed = TRUE;
1280 break;
1281 }
1282 }
1283
1284 #if BTA_HL_DEBUG == TRUE
1285 APPL_TRACE_DEBUG1("bta_hl_is_the_first_reliable_existed is_existed=%d ",is_existed );
1286 #endif
1287 return is_existed;
1288 }
1289
1290 /*******************************************************************************
1291 **
1292 ** Function bta_hl_find_non_active_mdl_cfg
1293 **
1294 ** Description This function finds a valid MDL configiration index and this
1295 ** MDL ID is not active
1296 **
1297 ** Returns BOOLEAN - TRUE found
1298 ** FALSE not found
1299 **
1300 *******************************************************************************/
bta_hl_find_non_active_mdl_cfg(UINT8 app_idx,UINT8 start_mdl_cfg_idx,UINT8 * p_mdl_cfg_idx)1301 BOOLEAN bta_hl_find_non_active_mdl_cfg(UINT8 app_idx, UINT8 start_mdl_cfg_idx,
1302 UINT8 *p_mdl_cfg_idx)
1303 {
1304
1305 tBTA_HL_MCL_CB *p_mcb;
1306 tBTA_HL_MDL_CB *p_dcb;
1307 tBTA_HL_MDL_CFG *p_mdl;
1308 BOOLEAN mdl_in_use;
1309 BOOLEAN found = FALSE;
1310 UINT8 i,j,k;
1311
1312 for (i = start_mdl_cfg_idx; i< BTA_HL_NUM_MDL_CFGS; i++)
1313 {
1314 mdl_in_use = FALSE;
1315 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1316 for (j=0; j< BTA_HL_NUM_MCLS; j++)
1317 {
1318 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, j);
1319 if (p_mcb->in_use &&
1320 !memcmp(p_mdl->peer_bd_addr,p_mcb->bd_addr,BD_ADDR_LEN))
1321 {
1322
1323 for (k=0; k<BTA_HL_NUM_MDLS_PER_MCL; k++)
1324 {
1325 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, j, k);
1326
1327 if (p_dcb->in_use && p_mdl->mdl_id == p_dcb->mdl_id)
1328 {
1329 mdl_in_use = TRUE;
1330 break;
1331 }
1332 }
1333 }
1334
1335 if (mdl_in_use)
1336 {
1337 break;
1338 }
1339 }
1340
1341 if (!mdl_in_use)
1342 {
1343 *p_mdl_cfg_idx = i;
1344 found = TRUE;
1345 break;
1346 }
1347 }
1348
1349 return found;
1350 }
1351
1352 /*******************************************************************************
1353 **
1354 ** Function bta_hl_find_mdl_cfg_idx
1355 **
1356 ** Description This function finds an available MDL configiration index
1357 **
1358 ** Returns BOOLEAN - TRUE found
1359 ** FALSE not found
1360 **
1361 *******************************************************************************/
bta_hl_find_avail_mdl_cfg_idx(UINT8 app_idx,UINT8 mcl_idx,UINT8 * p_mdl_cfg_idx)1362 BOOLEAN bta_hl_find_avail_mdl_cfg_idx(UINT8 app_idx, UINT8 mcl_idx,
1363 UINT8 *p_mdl_cfg_idx)
1364 {
1365 tBTA_HL_MDL_CFG *p_mdl, *p_mdl1, *p_mdl2;
1366 UINT8 i;
1367 BOOLEAN found=FALSE;
1368 UINT8 first_mdl_cfg_idx, second_mdl_cfg_idx, older_mdl_cfg_idx;
1369 BOOLEAN done;
1370
1371
1372 for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1373 {
1374 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1375 if (!p_mdl->active )
1376 {
1377 /* found an unused space to store mdl cfg*/
1378 found=TRUE;
1379 *p_mdl_cfg_idx =i;
1380 break;
1381 }
1382 }
1383
1384 if (!found)
1385 {
1386 /* all available mdl cfg spaces are in use so we need to find the mdl cfg which is
1387 not currently in use and has the the oldest time stamp to remove*/
1388
1389 found = TRUE;
1390 if (bta_hl_find_non_active_mdl_cfg(app_idx,0, &first_mdl_cfg_idx))
1391 {
1392 if (bta_hl_find_non_active_mdl_cfg(app_idx,(UINT8) (first_mdl_cfg_idx+1), &second_mdl_cfg_idx))
1393 {
1394 done = FALSE;
1395 while (!done)
1396 {
1397 p_mdl1 = BTA_HL_GET_MDL_CFG_PTR(app_idx, first_mdl_cfg_idx);
1398 p_mdl2 = BTA_HL_GET_MDL_CFG_PTR(app_idx, second_mdl_cfg_idx);
1399
1400 if (p_mdl1->time < p_mdl2->time)
1401 {
1402 older_mdl_cfg_idx = first_mdl_cfg_idx;
1403 }
1404 else
1405 {
1406 older_mdl_cfg_idx = second_mdl_cfg_idx;
1407 }
1408
1409 if (bta_hl_find_non_active_mdl_cfg(app_idx,(UINT8) (second_mdl_cfg_idx+1), &second_mdl_cfg_idx))
1410 {
1411 first_mdl_cfg_idx = older_mdl_cfg_idx;
1412 }
1413 else
1414 {
1415 done = TRUE;
1416 }
1417 }
1418
1419 *p_mdl_cfg_idx = older_mdl_cfg_idx;
1420
1421 }
1422 else
1423 {
1424 *p_mdl_cfg_idx = first_mdl_cfg_idx;
1425 }
1426
1427 }
1428 else
1429 {
1430 found = FALSE;
1431 }
1432 }
1433
1434 #if BTA_HL_DEBUG == TRUE
1435 if (!found)
1436 {
1437 APPL_TRACE_DEBUG2("bta_hl_find_avail_mdl_cfg_idx found=%d mdl_cfg_idx=%d ",found, *p_mdl_cfg_idx );
1438 }
1439 #endif
1440
1441 return found;
1442
1443
1444 }
1445
1446 /*******************************************************************************
1447 **
1448 ** Function bta_hl_find_mdl_cfg_idx
1449 **
1450 ** Description This function finds the MDL configuration index based on
1451 ** the MDL ID
1452 **
1453 ** Returns BOOLEAN - TRUE found
1454 ** FALSE not found
1455 **
1456 *******************************************************************************/
bta_hl_find_mdl_cfg_idx(UINT8 app_idx,UINT8 mcl_idx,tBTA_HL_MDL_ID mdl_id,UINT8 * p_mdl_cfg_idx)1457 BOOLEAN bta_hl_find_mdl_cfg_idx(UINT8 app_idx, UINT8 mcl_idx,
1458 tBTA_HL_MDL_ID mdl_id, UINT8 *p_mdl_cfg_idx)
1459 {
1460 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1461 tBTA_HL_MDL_CFG *p_mdl;
1462 UINT8 i ;
1463 BOOLEAN found=FALSE;
1464 for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1465 {
1466 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1467 if(p_mdl->active)
1468 APPL_TRACE_DEBUG2("bta_hl_find_mdl_cfg_idx: mdl_id =%d, p_mdl->mdl_id=%d",mdl_id,
1469 p_mdl->mdl_id);
1470 if (p_mdl->active &&
1471 (!memcmp (p_mcb->bd_addr, p_mdl->peer_bd_addr, BD_ADDR_LEN))&&
1472 (p_mdl->mdl_id == mdl_id))
1473 {
1474 found=TRUE;
1475 *p_mdl_cfg_idx =i;
1476 break;
1477 }
1478 }
1479
1480 #if BTA_HL_DEBUG == TRUE
1481 if (!found)
1482 {
1483 APPL_TRACE_DEBUG2("bta_hl_find_mdl_cfg_idx found=%d mdl_cfg_idx=%d ",found, i );
1484 }
1485 #endif
1486
1487 return found;
1488
1489
1490 }
1491
1492
1493 /*******************************************************************************
1494 **
1495 ** Function bta_hl_get_cur_time
1496 **
1497 ** Description This function get the cuurent time value
1498 **
1499 ** Returns BOOLEAN - TRUE found
1500 ** FALSE not found
1501 **
1502 *******************************************************************************/
bta_hl_get_cur_time(UINT8 app_idx,UINT8 * p_cur_time)1503 BOOLEAN bta_hl_get_cur_time(UINT8 app_idx, UINT8 *p_cur_time)
1504 {
1505 tBTA_HL_MDL_CFG *p_mdl;
1506 UINT8 i, j, time_latest, time;
1507 BOOLEAN found=FALSE, result=TRUE;
1508
1509 for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1510 {
1511 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1512 if (p_mdl->active)
1513 {
1514 found=TRUE;
1515 time_latest = p_mdl->time;
1516 for (j=(i+1); j< BTA_HL_NUM_MDL_CFGS; j++ )
1517 {
1518 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, j);
1519 if (p_mdl->active)
1520 {
1521 time = p_mdl->time;
1522 if (time > time_latest)
1523 {
1524 time_latest = time;
1525 }
1526 }
1527 }
1528 break;
1529 }
1530 }
1531
1532
1533 if (found)
1534 {
1535 if (time_latest < BTA_HL_MAX_TIME)
1536 {
1537 *p_cur_time = time_latest+1;
1538 }
1539 else
1540 {
1541 /* need to wrap around */
1542 result = FALSE;
1543 }
1544 }
1545 else
1546 {
1547 *p_cur_time = BTA_HL_MIN_TIME;
1548 }
1549
1550 #if BTA_HL_DEBUG == TRUE
1551 if (!result)
1552 {
1553 APPL_TRACE_DEBUG2("bta_hl_get_cur_time result=%s cur_time=%d",
1554 (result?"OK":"FAIL"), *p_cur_time);
1555 }
1556 #endif
1557
1558 return result;
1559 }
1560
1561 /*******************************************************************************
1562 **
1563 ** Function bta_hl_sort_cfg_time_idx
1564 **
1565 ** Description This function sort the mdl configuration idx stored in array a
1566 ** based on decending time value
1567 **
1568 ** Returns BOOLEAN - TRUE found
1569 ** FALSE not found
1570 **
1571 *******************************************************************************/
bta_hl_sort_cfg_time_idx(UINT8 app_idx,UINT8 * a,UINT8 n)1572 void bta_hl_sort_cfg_time_idx(UINT8 app_idx, UINT8 *a, UINT8 n)
1573 {
1574 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1575 UINT8 temp_time, temp_idx;
1576 INT16 i, j;
1577 for (i = 1; i < n; ++i)
1578 {
1579 temp_idx = a[i];
1580 temp_time = p_acb->mdl_cfg[temp_idx].time;
1581 j = i - 1;
1582 while ((j >= 0) && (temp_time < p_acb->mdl_cfg[a[j]].time))
1583 {
1584 a[j + 1] = a[j];
1585 --j;
1586 }
1587 a[j + 1] = temp_idx;
1588 }
1589 }
1590
1591 /*******************************************************************************
1592 **
1593 ** Function bta_hl_compact_mdl_cfg_time
1594 **
1595 ** Description This function finds the MDL configuration index based on
1596 ** the MDL ID
1597 **
1598 ** Returns BOOLEAN - TRUE found
1599 ** FALSE not found
1600 **
1601 *******************************************************************************/
bta_hl_compact_mdl_cfg_time(UINT8 app_idx,UINT8 mdep_id)1602 void bta_hl_compact_mdl_cfg_time(UINT8 app_idx, UINT8 mdep_id)
1603 {
1604 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1605 tBTA_HL_MDL_CFG *p_mdl;
1606 UINT8 i, time_min, cnt=0;
1607 UINT8 s_arr[BTA_HL_NUM_MDL_CFGS];
1608
1609
1610 for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1611 {
1612 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1613 if (p_mdl->active )
1614 {
1615 s_arr[cnt]= i;
1616 cnt++;
1617 }
1618 }
1619
1620
1621
1622 #if BTA_HL_DEBUG == TRUE
1623 APPL_TRACE_DEBUG1("bta_hl_compact_mdl_cfg_time cnt=%d ",cnt );
1624 #endif
1625
1626
1627 if (cnt)
1628 {
1629 bta_hl_sort_cfg_time_idx(app_idx, s_arr, cnt);
1630 time_min = BTA_HL_MIN_TIME;
1631 for (i=0;i<cnt; i++)
1632 {
1633 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, s_arr[i]);
1634 p_mdl->time = time_min + i;
1635 bta_hl_co_save_mdl(mdep_id, s_arr[i], p_mdl);
1636 }
1637 }
1638
1639
1640 }
1641
1642
1643
1644 /*******************************************************************************
1645 **
1646 ** Function bta_hl_is_mdl_exsit_in_mcl
1647 **
1648 ** Description This function checks whether the MDL ID
1649 ** has already existed in teh MCL or not
1650 **
1651 ** Returns BOOLEAN - TRUE exist
1652 ** FALSE does not exist
1653 **
1654 *******************************************************************************/
bta_hl_is_mdl_exsit_in_mcl(UINT8 app_idx,BD_ADDR bd_addr,tBTA_HL_MDL_ID mdl_id)1655 BOOLEAN bta_hl_is_mdl_exsit_in_mcl(UINT8 app_idx, BD_ADDR bd_addr,
1656 tBTA_HL_MDL_ID mdl_id)
1657 {
1658 tBTA_HL_MDL_CFG *p_mdl;
1659 BOOLEAN found = FALSE;
1660 UINT8 i;
1661
1662 for (i = 0; i< BTA_HL_NUM_MDL_CFGS; i++)
1663 {
1664 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1665 if (p_mdl->active &&
1666 !memcmp(p_mdl->peer_bd_addr, bd_addr,BD_ADDR_LEN))
1667 {
1668 if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS)
1669 {
1670 if (p_mdl->mdl_id == mdl_id)
1671 {
1672 found = TRUE;
1673 break;
1674 }
1675 }
1676 else
1677 {
1678 found = TRUE;
1679 break;
1680 }
1681 }
1682 }
1683
1684 return found;
1685 }
1686
1687 /*******************************************************************************
1688 **
1689 ** Function bta_hl_delete_mdl_cfg
1690 **
1691 ** Description This function delete the specified MDL ID
1692 **
1693 ** Returns BOOLEAN - TRUE Success
1694 ** FALSE Failed
1695 **
1696 *******************************************************************************/
bta_hl_delete_mdl_cfg(UINT8 app_idx,BD_ADDR bd_addr,tBTA_HL_MDL_ID mdl_id)1697 BOOLEAN bta_hl_delete_mdl_cfg(UINT8 app_idx, BD_ADDR bd_addr,
1698 tBTA_HL_MDL_ID mdl_id)
1699 {
1700 tBTA_HL_MDL_CFG *p_mdl;
1701 BOOLEAN success = FALSE;
1702 UINT8 i;
1703 tBTA_HL_APP_CB *p_acb= BTA_HL_GET_APP_CB_PTR(app_idx);
1704 UINT8 app_id = p_acb->app_id;
1705
1706 for (i = 0; i< BTA_HL_NUM_MDL_CFGS; i++)
1707 {
1708 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1709 if (p_mdl->active &&
1710 !memcmp(p_mdl->peer_bd_addr, bd_addr,BD_ADDR_LEN))
1711 {
1712 if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS)
1713 {
1714 if (p_mdl->mdl_id == mdl_id)
1715 {
1716 bta_hl_co_delete_mdl(p_mdl->local_mdep_id, i);
1717 memset(p_mdl, 0, sizeof(tBTA_HL_MDL_CFG));
1718 success = TRUE;
1719 break;
1720 }
1721 }
1722 else
1723 {
1724 bta_hl_co_delete_mdl(p_mdl->local_mdep_id, i);
1725 memset(p_mdl, 0, sizeof(tBTA_HL_MDL_CFG));
1726 success = TRUE;
1727 }
1728 }
1729 }
1730
1731 return success;
1732 }
1733
1734
1735 /*******************************************************************************
1736 **
1737 ** Function bta_hl_is_mdl_value_valid
1738 **
1739 **
1740 ** Description This function checks the specified MDL ID is in valid range or not
1741 **
1742 ** Returns BOOLEAN - TRUE Success
1743 ** FALSE Failed
1744 **
1745 ** note: mdl_id range 0x0000 reserved,
1746 ** 0x0001-oxFEFF dynamic range,
1747 ** 0xFF00-0xFFFE reserved,
1748 ** 0xFFFF indicates all MDLs (for delete operation only)
1749 **
1750 *******************************************************************************/
bta_hl_is_mdl_value_valid(tBTA_HL_MDL_ID mdl_id)1751 BOOLEAN bta_hl_is_mdl_value_valid(tBTA_HL_MDL_ID mdl_id)
1752 {
1753 BOOLEAN status = TRUE;
1754
1755 if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS)
1756 {
1757 if (mdl_id != 0)
1758 {
1759 if (mdl_id > BTA_HL_MAX_MDL_VAL )
1760 {
1761 status = FALSE;
1762 }
1763 }
1764 else
1765 {
1766 status = FALSE;
1767 }
1768 }
1769
1770 return status;
1771 }
1772
1773 /*******************************************************************************
1774 **
1775 ** Function bta_hl_find_mdep_cfg_idx
1776 **
1777 ** Description This function finds the MDEP configuration index based
1778 ** on the local MDEP ID
1779 **
1780 ** Returns BOOLEAN - TRUE found
1781 ** FALSE not found
1782 **
1783 *******************************************************************************/
bta_hl_find_mdep_cfg_idx(UINT8 app_idx,tBTA_HL_MDEP_ID local_mdep_id,UINT8 * p_mdep_cfg_idx)1784 BOOLEAN bta_hl_find_mdep_cfg_idx(UINT8 app_idx, tBTA_HL_MDEP_ID local_mdep_id,
1785 UINT8 *p_mdep_cfg_idx)
1786 {
1787 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1788 tBTA_HL_SUP_FEATURE *p_sup_feature= &p_acb->sup_feature;
1789 BOOLEAN found =FALSE;
1790 UINT8 i;
1791
1792 for (i=0; i< p_sup_feature->num_of_mdeps; i++)
1793 {
1794 if ( p_sup_feature->mdep[i].mdep_id == local_mdep_id)
1795 {
1796 found = TRUE;
1797 *p_mdep_cfg_idx = i;
1798 break;
1799 }
1800 }
1801
1802 #if BTA_HL_DEBUG == TRUE
1803 if (!found)
1804 {
1805 APPL_TRACE_DEBUG3("bta_hl_find_mdep_cfg_idx found=%d mdep_idx=%d local_mdep_id=%d ",
1806 found,i, local_mdep_id );
1807 }
1808 #endif
1809 return found;
1810 }
1811
1812
1813 /*******************************************************************************
1814 **
1815 ** Function bta_hl_find_rxtx_apdu_size
1816 **
1817 ** Description This function finds the maximum APDU rx and tx sizes based on
1818 ** the MDEP configuration data
1819 **
1820 ** Returns void
1821 **
1822 *******************************************************************************/
bta_hl_find_rxtx_apdu_size(UINT8 app_idx,UINT8 mdep_cfg_idx,UINT16 * p_rx_apu_size,UINT16 * p_tx_apu_size)1823 void bta_hl_find_rxtx_apdu_size(UINT8 app_idx, UINT8 mdep_cfg_idx,
1824 UINT16 *p_rx_apu_size,
1825 UINT16 *p_tx_apu_size)
1826 {
1827 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1828 tBTA_HL_MDEP_CFG *p_mdep_cfg;
1829 UINT8 i;
1830 UINT16 max_rx_apdu_size=0, max_tx_apdu_size=0;
1831
1832 p_mdep_cfg = &p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg;
1833
1834
1835 for (i=0; i< p_mdep_cfg->num_of_mdep_data_types ; i++)
1836 {
1837
1838 if (max_rx_apdu_size < p_mdep_cfg->data_cfg[i].max_rx_apdu_size)
1839 {
1840 max_rx_apdu_size = p_mdep_cfg->data_cfg[i].max_rx_apdu_size;
1841 }
1842
1843 if (max_tx_apdu_size < p_mdep_cfg->data_cfg[i].max_tx_apdu_size)
1844 {
1845 max_tx_apdu_size = p_mdep_cfg->data_cfg[i].max_tx_apdu_size;
1846 }
1847 }
1848
1849
1850 *p_rx_apu_size = max_rx_apdu_size;
1851 *p_tx_apu_size = max_tx_apdu_size;
1852
1853 #if BTA_HL_DEBUG == TRUE
1854 APPL_TRACE_DEBUG2("bta_hl_find_rxtx_apdu_size max_rx_apdu_size=%d max_tx_apdu_size=%d ",
1855 max_rx_apdu_size, max_tx_apdu_size );
1856 #endif
1857
1858
1859 }
1860
1861 /*******************************************************************************
1862 **
1863 ** Function bta_hl_validate_peer_cfg
1864 **
1865 ** Description This function validates the peer DCH configuration
1866 **
1867 ** Returns BOOLEAN - TRUE validation is successful
1868 ** FALSE validation failed
1869 **
1870 *******************************************************************************/
bta_hl_validate_peer_cfg(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdl_idx,tBTA_HL_MDEP_ID peer_mdep_id,tBTA_HL_MDEP_ROLE peer_mdep_role,UINT8 sdp_idx)1871 BOOLEAN bta_hl_validate_peer_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
1872 tBTA_HL_MDEP_ID peer_mdep_id,
1873 tBTA_HL_MDEP_ROLE peer_mdep_role,
1874 UINT8 sdp_idx)
1875 {
1876 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1877 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1878 tBTA_HL_SDP_REC *p_rec;
1879 BOOLEAN peer_found =FALSE;
1880 UINT8 i;
1881
1882 APPL_TRACE_DEBUG2("bta_hl_validate_peer_cfg sdp_idx=%d app_idx %d", sdp_idx, app_idx);
1883
1884
1885 if (p_dcb->local_mdep_id == BTA_HL_ECHO_TEST_MDEP_ID)
1886 {
1887 return TRUE;
1888 }
1889
1890 p_rec = &p_mcb->sdp.sdp_rec[sdp_idx];
1891 for (i=0; i< p_rec->num_mdeps; i++)
1892 {
1893 APPL_TRACE_DEBUG2("mdep_id %d peer_mdep_id %d",p_rec->mdep_cfg[i].mdep_id , peer_mdep_id);
1894 APPL_TRACE_DEBUG2("mdep_role %d peer_mdep_role %d",p_rec->mdep_cfg[i].mdep_role,
1895 peer_mdep_role)
1896 if ( (p_rec->mdep_cfg[i].mdep_id == peer_mdep_id) &&
1897 (p_rec->mdep_cfg[i].mdep_role == peer_mdep_role))
1898 {
1899 peer_found = TRUE;
1900
1901 break;
1902 }
1903 }
1904
1905 #if BTA_HL_DEBUG == TRUE
1906 if (!peer_found)
1907 {
1908 APPL_TRACE_DEBUG1("bta_hl_validate_peer_cfg failed num_mdeps=%d",p_rec->num_mdeps);
1909 }
1910 #endif
1911 return peer_found;
1912 }
1913
1914 /*******************************************************************************
1915 **
1916 ** Function bta_hl_chk_local_cfg
1917 **
1918 ** Description This function check whether the local DCH configuration is OK or not
1919 **
1920 ** Returns tBTA_HL_STATUS - OK - local DCH configuration is OK
1921 ** NO_FIRST_RELIABLE - the streaming DCH configuration
1922 ** is not OK and it needs to use
1923 ** reliable DCH configuration
1924 **
1925 *******************************************************************************/
bta_hl_chk_local_cfg(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdep_cfg_idx,tBTA_HL_DCH_CFG local_cfg)1926 tBTA_HL_STATUS bta_hl_chk_local_cfg(UINT8 app_idx, UINT8 mcl_idx,
1927 UINT8 mdep_cfg_idx,
1928 tBTA_HL_DCH_CFG local_cfg)
1929 {
1930 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1931 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
1932
1933 if ( mdep_cfg_idx &&
1934 (p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SOURCE) &&
1935 (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx)) &&
1936 (local_cfg != BTA_HL_DCH_CFG_RELIABLE))
1937 {
1938 status = BTA_HL_STATUS_NO_FIRST_RELIABLE;
1939 APPL_TRACE_ERROR0("BTA_HL_STATUS_INVALID_DCH_CFG");
1940 }
1941
1942 return status;
1943 }
1944
1945
1946 /*******************************************************************************
1947 **
1948 ** Function bta_hl_validate_reconnect_params
1949 **
1950 ** Description This function validates the reconnect parameters
1951 **
1952 ** Returns BOOLEAN - TRUE validation is successful
1953 ** FALSE validation failed
1954 *******************************************************************************/
bta_hl_validate_reconnect_params(UINT8 app_idx,UINT8 mcl_idx,tBTA_HL_API_DCH_RECONNECT * p_reconnect,UINT8 * p_mdep_cfg_idx,UINT8 * p_mdl_cfg_idx)1955 BOOLEAN bta_hl_validate_reconnect_params(UINT8 app_idx, UINT8 mcl_idx,
1956 tBTA_HL_API_DCH_RECONNECT *p_reconnect,
1957 UINT8 *p_mdep_cfg_idx, UINT8 *p_mdl_cfg_idx)
1958 {
1959 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1960 tBTA_HL_SUP_FEATURE *p_sup_feature = &p_acb->sup_feature;
1961 UINT8 num_mdeps;
1962 UINT8 mdl_cfg_idx;
1963 BOOLEAN local_mdep_id_found =FALSE;
1964 BOOLEAN mdl_cfg_found =FALSE;
1965 BOOLEAN status=FALSE;
1966 UINT8 i, in_use_mdl_idx = 0;
1967
1968 #if BTA_HL_DEBUG == TRUE
1969 APPL_TRACE_DEBUG2("bta_hl_validate_reconnect_params mdl_id=%d app_idx=%d", p_reconnect->mdl_id, app_idx);
1970 #endif
1971 if (bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, p_reconnect->mdl_id, &mdl_cfg_idx))
1972 {
1973 mdl_cfg_found = TRUE;
1974 }
1975
1976 #if BTA_HL_DEBUG == TRUE
1977 if (!mdl_cfg_found)
1978 {
1979 APPL_TRACE_DEBUG0("mdl_cfg_found not found");
1980 }
1981 #endif
1982
1983
1984 if (mdl_cfg_found)
1985 {
1986 num_mdeps = p_sup_feature->num_of_mdeps;
1987 for (i=0; i< num_mdeps ; i++)
1988 {
1989 if ( p_sup_feature->mdep[i].mdep_id == p_acb->mdl_cfg[mdl_cfg_idx].local_mdep_id)
1990 {
1991 local_mdep_id_found = TRUE;
1992 *p_mdep_cfg_idx =i;
1993 *p_mdl_cfg_idx = mdl_cfg_idx;
1994 break;
1995 }
1996 }
1997 }
1998
1999 #if BTA_HL_DEBUG == TRUE
2000 if (!local_mdep_id_found)
2001 {
2002 APPL_TRACE_DEBUG0("local_mdep_id not found");
2003 }
2004 #endif
2005
2006
2007 if (local_mdep_id_found)
2008 {
2009 if (!bta_hl_find_mdl_idx(app_idx,mcl_idx, p_reconnect->mdl_id, &in_use_mdl_idx))
2010 {
2011 status= TRUE;
2012 }
2013 else
2014 {
2015 APPL_TRACE_ERROR1("mdl_id=%d is curreltly in use",p_reconnect->mdl_id);
2016 }
2017 }
2018
2019 #if BTA_HL_DEBUG == TRUE
2020 if (!status)
2021 {
2022 APPL_TRACE_DEBUG3("Reconnect validation failed local_mdep_id found=%d mdl_cfg_idx found=%d in_use_mdl_idx=%d ",
2023 local_mdep_id_found, mdl_cfg_found, in_use_mdl_idx);
2024 }
2025 #endif
2026 return status;
2027 }
2028
2029 /*******************************************************************************
2030 **
2031 ** Function bta_hl_find_avail_mcl_idx
2032 **
2033 ** Returns BOOLEAN - TRUE found
2034 ** FALSE not found
2035 **
2036 *******************************************************************************/
bta_hl_find_avail_mcl_idx(UINT8 app_idx,UINT8 * p_mcl_idx)2037 BOOLEAN bta_hl_find_avail_mcl_idx(UINT8 app_idx, UINT8 *p_mcl_idx)
2038 {
2039 BOOLEAN found=FALSE;
2040 UINT8 i;
2041
2042 for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
2043 {
2044 if (!bta_hl_cb.acb[app_idx].mcb[i].in_use)
2045 {
2046 found = TRUE;
2047 *p_mcl_idx = i;
2048 break;
2049 }
2050 }
2051
2052 #if BTA_HL_DEBUG == TRUE
2053 if (!found)
2054 {
2055 APPL_TRACE_DEBUG2("bta_hl_find_avail_mcl_idx found=%d idx=%d",
2056 found, i);
2057 }
2058 #endif
2059 return found;
2060 }
2061
2062
2063
2064 /*******************************************************************************
2065 **
2066 ** Function bta_hl_find_avail_mdl_idx
2067 **
2068 ** Description This function finds an available MDL control block index
2069 **
2070 ** Returns BOOLEAN - TRUE found
2071 ** FALSE not found
2072 **
2073 *******************************************************************************/
bta_hl_find_avail_mdl_idx(UINT8 app_idx,UINT8 mcl_idx,UINT8 * p_mdl_idx)2074 BOOLEAN bta_hl_find_avail_mdl_idx(UINT8 app_idx, UINT8 mcl_idx,
2075 UINT8 *p_mdl_idx)
2076 {
2077 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2078 BOOLEAN found=FALSE;
2079 UINT8 i;
2080
2081 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
2082 {
2083 if (!p_mcb->mdl[i].in_use)
2084 {
2085 memset((void *)&p_mcb->mdl[i],0, sizeof(tBTA_HL_MDL_CB));
2086 found = TRUE;
2087 *p_mdl_idx = i;
2088 break;
2089 }
2090 }
2091
2092 #if BTA_HL_DEBUG == TRUE
2093 if (!found)
2094 {
2095 APPL_TRACE_DEBUG2("bta_hl_find_avail_mdl_idx found=%d idx=%d",
2096 found, i);
2097 }
2098 #endif
2099 return found;
2100 }
2101
2102 /*******************************************************************************
2103 **
2104 ** Function bta_hl_is_a_duplicate_id
2105 **
2106 ** Description This function finds the application has been used or not
2107 **
2108 ** Returns BOOLEAN - TRUE the app_id is a duplicate ID
2109 ** FALSE not a duplicate ID
2110 *******************************************************************************/
bta_hl_is_a_duplicate_id(UINT8 app_id)2111 BOOLEAN bta_hl_is_a_duplicate_id(UINT8 app_id)
2112 {
2113 BOOLEAN is_duplicate=FALSE;
2114 UINT8 i;
2115
2116 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
2117 {
2118 if (bta_hl_cb.acb[i].in_use &&
2119 (bta_hl_cb.acb[i].app_id == app_id))
2120 {
2121 is_duplicate = TRUE;
2122
2123 break;
2124 }
2125 }
2126
2127 #if BTA_HL_DEBUG == TRUE
2128 if (is_duplicate)
2129 {
2130
2131 APPL_TRACE_DEBUG2("bta_hl_is_a_duplicate_id app_id=%d is_duplicate=%d",
2132 app_id, is_duplicate);
2133 }
2134 #endif
2135
2136 return is_duplicate;
2137 }
2138
2139
2140 /*******************************************************************************
2141 **
2142 ** Function bta_hl_find_avail_app_idx
2143 **
2144 ** Description This function finds an available application control block index
2145 **
2146 ** Returns BOOLEAN - TRUE found
2147 ** FALSE not found
2148 **
2149 *******************************************************************************/
bta_hl_find_avail_app_idx(UINT8 * p_idx)2150 BOOLEAN bta_hl_find_avail_app_idx(UINT8 *p_idx)
2151 {
2152 BOOLEAN found=FALSE;
2153 UINT8 i;
2154
2155 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
2156 {
2157 if (!bta_hl_cb.acb[i].in_use)
2158 {
2159 found = TRUE;
2160 *p_idx = i;
2161 break;
2162 }
2163 }
2164
2165 #if BTA_HL_DEBUG == TRUE
2166 if (!found)
2167 {
2168 APPL_TRACE_DEBUG2("bta_hl_find_avail_app_idx found=%d app_idx=%d",
2169 found, i);
2170 }
2171 #endif
2172 return found;
2173 }
2174
2175 /*******************************************************************************
2176 **
2177 ** Function bta_hl_app_update
2178 **
2179 ** Description This function registers an HDP application MCAP and DP
2180 **
2181 ** Returns tBTA_HL_STATUS -registration status
2182 **
2183 *******************************************************************************/
bta_hl_app_update(UINT8 app_id,BOOLEAN is_register)2184 tBTA_HL_STATUS bta_hl_app_update(UINT8 app_id, BOOLEAN is_register)
2185 {
2186 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
2187 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(0);
2188 tMCA_CS mca_cs;
2189 UINT8 i, mdep_idx, num_of_mdeps;
2190 UINT8 mdep_counter = 0;
2191
2192
2193 #if BTA_HL_DEBUG == TRUE
2194 APPL_TRACE_DEBUG1("bta_hl_app_update app_id=%d", app_id);
2195 #endif
2196
2197 if (is_register)
2198 {
2199 if ((status == BTA_HL_STATUS_OK) &&
2200 bta_hl_co_get_num_of_mdep(app_id, &num_of_mdeps))
2201 {
2202 for (i=0; i < num_of_mdeps; i++)
2203 {
2204 mca_cs.type = MCA_TDEP_DATA;
2205 mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
2206 mca_cs.p_data_cback = bta_hl_mcap_data_cback;
2207 /* Find the first available mdep index, and create a MDL Endpoint */
2208 // make a function later if needed
2209 for (mdep_idx = 1; mdep_idx < BTA_HL_NUM_MDEPS; mdep_idx++)
2210 {
2211 if ( p_acb->sup_feature.mdep[mdep_idx].mdep_id == 0)
2212 {
2213 break; /* We found an available index */
2214 }
2215 else
2216 {
2217 mdep_counter++;
2218 }
2219 }
2220 /* If no available MDEPs, return error */
2221 if (mdep_idx == BTA_HL_NUM_MDEPS)
2222 {
2223 APPL_TRACE_ERROR0("bta_hl_app_update: Out of MDEP IDs");
2224 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2225 break;
2226 }
2227 if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
2228 &(p_acb->sup_feature.mdep[mdep_idx].mdep_id), &mca_cs) == MCA_SUCCESS)
2229 {
2230 if (bta_hl_co_get_mdep_config(app_id,
2231 mdep_idx,
2232 mdep_counter,
2233 p_acb->sup_feature.mdep[mdep_idx].mdep_id,
2234 &p_acb->sup_feature.mdep[mdep_idx].mdep_cfg))
2235 {
2236 p_acb->sup_feature.mdep[mdep_idx].ori_app_id = app_id;
2237 APPL_TRACE_DEBUG4("mdep idx %d id %d ori_app_id %d num data type %d",mdep_idx,
2238 p_acb->sup_feature.mdep[mdep_idx].mdep_id,
2239 p_acb->sup_feature.mdep[mdep_idx].ori_app_id,
2240 p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.num_of_mdep_data_types);
2241 if (p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.mdep_role ==
2242 BTA_HL_MDEP_ROLE_SOURCE)
2243 {
2244 p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SOURCE;
2245 }
2246 else if (p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.mdep_role ==
2247 BTA_HL_MDEP_ROLE_SINK)
2248 {
2249 p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SINK;
2250 }
2251 else
2252 {
2253 APPL_TRACE_ERROR1("bta_hl_app_registration: Invalid Role %d",
2254 p_acb->sup_feature.mdep[mdep_idx].mdep_cfg.mdep_role);
2255 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2256 break;
2257 }
2258 }
2259 else
2260 {
2261 APPL_TRACE_ERROR0("bta_hl_app_registration: Cfg callout failed");
2262 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2263 break;
2264 }
2265 }
2266 else
2267 {
2268 APPL_TRACE_ERROR0("bta_hl_app_registration: MCA_CreateDep failed");
2269 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2270 break;
2271 }
2272
2273 }
2274 p_acb->sup_feature.num_of_mdeps += num_of_mdeps;
2275 APPL_TRACE_DEBUG1("num_of_mdeps %d", p_acb->sup_feature.num_of_mdeps);
2276
2277 if ((status == BTA_HL_STATUS_OK) &&
2278 (p_acb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SOURCE))
2279 {
2280 p_acb->sup_feature.advertize_source_sdp =
2281 bta_hl_co_advrtise_source_sdp(app_id);
2282 }
2283
2284 if ((status == BTA_HL_STATUS_OK)&&
2285 (!bta_hl_co_get_echo_config(app_id, &p_acb->sup_feature.echo_cfg)))
2286 {
2287 status = BTA_HL_STATUS_ECHO_CO_FAIL;
2288 }
2289
2290 if ((status == BTA_HL_STATUS_OK)&&
2291 (!bta_hl_co_load_mdl_config(app_id, BTA_HL_NUM_MDL_CFGS, &p_acb->mdl_cfg[0])))
2292 {
2293 status = BTA_HL_STATUS_MDL_CFG_CO_FAIL;
2294 }
2295 }
2296 else
2297 {
2298 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2299 }
2300 }
2301 else
2302 {
2303 for (i=1; i<BTA_HL_NUM_MDEPS; i++)
2304 {
2305 if (p_acb->sup_feature.mdep[i].ori_app_id == app_id)
2306 {
2307 APPL_TRACE_DEBUG1("Found index %", i);
2308
2309
2310 if (MCA_DeleteDep((tMCA_HANDLE)p_acb->app_handle,
2311 (p_acb->sup_feature.mdep[i].mdep_id)) != MCA_SUCCESS)
2312 {
2313 APPL_TRACE_ERROR0("Error deregistering");
2314 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2315 return status;
2316 }
2317 memset(&p_acb->sup_feature.mdep[i], 0, sizeof(tBTA_HL_MDEP));
2318 }
2319 }
2320
2321
2322 }
2323
2324 if (status == BTA_HL_STATUS_OK)
2325 {
2326 /* Register/Update MDEP(s) in SDP Record */
2327 status = bta_hl_sdp_update(app_id);
2328 }
2329 /* else do cleanup */
2330
2331
2332 return status;
2333 }
2334
2335
2336 /*******************************************************************************
2337 **
2338 ** Function bta_hl_app_registration
2339 **
2340 ** Description This function registers an HDP application MCAP and DP
2341 **
2342 ** Returns tBTA_HL_STATUS -registration status
2343 **
2344 *******************************************************************************/
bta_hl_app_registration(UINT8 app_idx)2345 tBTA_HL_STATUS bta_hl_app_registration(UINT8 app_idx)
2346 {
2347 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
2348 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2349 tMCA_REG reg;
2350 tMCA_CS mca_cs;
2351 UINT8 i, num_of_mdeps;
2352 UINT8 mdep_counter = 0;
2353
2354 #if BTA_HL_DEBUG == TRUE
2355 APPL_TRACE_DEBUG1("bta_hl_app_registration app_idx=%d", app_idx);
2356 #endif
2357
2358 reg.ctrl_psm = p_acb->ctrl_psm;
2359 reg.data_psm = p_acb->data_psm;
2360 reg.sec_mask = p_acb->sec_mask;
2361 reg.rsp_tout = BTA_HL_MCAP_RSP_TOUT;
2362
2363 if ( (p_acb->app_handle = (tBTA_HL_APP_HANDLE) MCA_Register(®, bta_hl_mcap_ctrl_cback))!=0)
2364 {
2365 mca_cs.type = MCA_TDEP_ECHO;
2366 mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
2367 mca_cs.p_data_cback = bta_hl_mcap_data_cback;
2368
2369 if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
2370 &(p_acb->sup_feature.mdep[0].mdep_id),
2371 &mca_cs) == MCA_SUCCESS)
2372 {
2373 if (p_acb->sup_feature.mdep[0].mdep_id != BTA_HL_ECHO_TEST_MDEP_ID)
2374 {
2375 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2376 APPL_TRACE_ERROR1("BAD MDEP ID for echo test mdep_id=%d",
2377 p_acb->sup_feature.mdep[0].mdep_id );
2378 }
2379 }
2380 else
2381 {
2382 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2383 APPL_TRACE_ERROR0("MCA_CreateDep for echo test(mdep_id=0) failed");
2384 }
2385
2386
2387 if ((status == BTA_HL_STATUS_OK) &&
2388 bta_hl_co_get_num_of_mdep(p_acb->app_id, &num_of_mdeps))
2389 {
2390 p_acb->sup_feature.num_of_mdeps = num_of_mdeps+1;
2391
2392 for (i=1; i<p_acb->sup_feature.num_of_mdeps; i++)
2393 {
2394 mca_cs.type = MCA_TDEP_DATA;
2395 mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
2396 mca_cs.p_data_cback = bta_hl_mcap_data_cback;
2397
2398 if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
2399 &(p_acb->sup_feature.mdep[i].mdep_id), &mca_cs) == MCA_SUCCESS)
2400 {
2401 if (bta_hl_co_get_mdep_config(p_acb->app_id,
2402 i,mdep_counter,
2403 p_acb->sup_feature.mdep[i].mdep_id,
2404 &p_acb->sup_feature.mdep[i].mdep_cfg))
2405 {
2406 if (p_acb->sup_feature.mdep[i].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
2407 {
2408 p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SOURCE;
2409 }
2410 else if (p_acb->sup_feature.mdep[i].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SINK)
2411 {
2412 p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SINK;
2413 }
2414 else
2415 {
2416 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2417 break;
2418 }
2419 p_acb->sup_feature.mdep[i].ori_app_id = p_acb->app_id;
2420 APPL_TRACE_DEBUG2("index %d ori_app_id %d", i,
2421 p_acb->sup_feature.mdep[i].ori_app_id);
2422 }
2423 else
2424 {
2425 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2426 break;
2427 }
2428 }
2429 else
2430 {
2431 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2432 break;
2433 }
2434 }
2435
2436
2437
2438 if ((status == BTA_HL_STATUS_OK) &&
2439 (p_acb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SOURCE))
2440 {
2441 /* this is a source only applciation */
2442 p_acb->sup_feature.advertize_source_sdp =
2443 bta_hl_co_advrtise_source_sdp(p_acb->app_id);
2444 }
2445
2446 if ((status == BTA_HL_STATUS_OK)&&
2447 (!bta_hl_co_get_echo_config(p_acb->app_id, &p_acb->sup_feature.echo_cfg)))
2448 {
2449 status = BTA_HL_STATUS_ECHO_CO_FAIL;
2450 }
2451
2452 if ((status == BTA_HL_STATUS_OK)&&
2453 (!bta_hl_co_load_mdl_config(p_acb->app_id, BTA_HL_NUM_MDL_CFGS, &p_acb->mdl_cfg[0])))
2454 {
2455 status = BTA_HL_STATUS_MDL_CFG_CO_FAIL;
2456 }
2457 }
2458 else
2459 {
2460 status = BTA_HL_STATUS_MDEP_CO_FAIL;
2461 }
2462 }
2463 else
2464 {
2465 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2466 }
2467
2468 if (status == BTA_HL_STATUS_OK)
2469 {
2470 status = bta_hl_sdp_register(app_idx);
2471 }
2472
2473 return status;
2474 }
2475
2476
2477 /*******************************************************************************
2478 **
2479 ** Function bta_hl_discard_data
2480 **
2481 ** Description This function discard an HDP event
2482 **
2483 ** Returns void
2484 **
2485 *******************************************************************************/
bta_hl_discard_data(UINT16 event,tBTA_HL_DATA * p_data)2486 void bta_hl_discard_data(UINT16 event, tBTA_HL_DATA *p_data)
2487 {
2488
2489 #if BTA_HL_DEBUG == TRUE
2490 APPL_TRACE_ERROR1("BTA HL Discard event=%s",bta_hl_evt_code(event));
2491
2492 #endif
2493
2494 switch (event)
2495 {
2496 case BTA_HL_API_SEND_DATA_EVT:
2497 break;
2498
2499 case BTA_HL_MCA_RCV_DATA_EVT:
2500 utl_freebuf((void**)&p_data->mca_rcv_data_evt.p_pkt);
2501 break;
2502
2503 default:
2504 /*Nothing to free*/
2505 break;
2506 }
2507 }
2508
2509 /*******************************************************************************
2510 **
2511 ** Function bta_hl_save_mdl_cfg
2512 **
2513 ** Description This function saves the MDL configuration
2514 **
2515 ** Returns void
2516 **
2517 *******************************************************************************/
bta_hl_save_mdl_cfg(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdl_idx)2518 void bta_hl_save_mdl_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx )
2519 {
2520 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2521 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2522 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2523 UINT8 mdl_cfg_idx;
2524 tBTA_HL_MDL_ID mdl_id;
2525 BOOLEAN found=TRUE;
2526 tBTA_HL_MDL_CFG mdl_cfg;
2527 tBTA_HL_MDEP *p_mdep_cfg;
2528 tBTA_HL_L2CAP_CFG_INFO l2cap_cfg;
2529 UINT8 time_val = 0;
2530 mdl_id = p_dcb->mdl_id;
2531 if (!bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, mdl_id, &mdl_cfg_idx))
2532 {
2533 if (!bta_hl_find_avail_mdl_cfg_idx(app_idx, mcl_idx, &mdl_cfg_idx))
2534 {
2535 APPL_TRACE_ERROR0("No space to save the MDL config");
2536 found= FALSE; /*no space available*/
2537 }
2538 }
2539
2540 if (found)
2541 {
2542 bta_hl_get_l2cap_cfg(p_dcb->mdl_handle, &l2cap_cfg);
2543 if (!bta_hl_get_cur_time(app_idx, &time_val ))
2544 {
2545 bta_hl_compact_mdl_cfg_time(app_idx,p_dcb->local_mdep_id);
2546 bta_hl_get_cur_time(app_idx, &time_val);
2547 }
2548 mdl_cfg.active = TRUE;
2549 mdl_cfg.time = time_val;
2550 mdl_cfg.mdl_id = p_dcb->mdl_id;
2551 mdl_cfg.dch_mode = p_dcb->dch_mode;
2552 mdl_cfg.mtu = l2cap_cfg.mtu;
2553 mdl_cfg.fcs = l2cap_cfg.fcs;
2554
2555 bdcpy(mdl_cfg.peer_bd_addr, p_mcb->bd_addr);
2556 mdl_cfg.local_mdep_id= p_dcb->local_mdep_id;
2557 p_mdep_cfg = &p_acb->sup_feature.mdep[p_dcb->local_mdep_cfg_idx];
2558 mdl_cfg.local_mdep_role= p_mdep_cfg->mdep_cfg.mdep_role;
2559 memcpy(&p_acb->mdl_cfg[mdl_cfg_idx], &mdl_cfg, sizeof(tBTA_HL_MDL_CFG));
2560 bta_hl_co_save_mdl(mdl_cfg.local_mdep_id, mdl_cfg_idx, &mdl_cfg);
2561 }
2562
2563 #if BTA_HL_DEBUG == TRUE
2564 if (found)
2565 {
2566 if (p_dcb->mtu != l2cap_cfg.mtu)
2567 {
2568 APPL_TRACE_WARNING2("MCAP and L2CAP peer mtu size out of sync from MCAP mtu=%d from l2cap mtu=%d",
2569 p_dcb->mtu, l2cap_cfg.mtu);
2570 }
2571 APPL_TRACE_DEBUG1("bta_hl_save_mdl_cfg saved=%d", found);
2572 APPL_TRACE_DEBUG4("Saved. L2cap cfg mdl_id=%d mtu=%d fcs=%d dch_mode=%d",
2573 mdl_cfg.mdl_id, mdl_cfg.mtu, mdl_cfg.fcs, mdl_cfg.dch_mode);
2574 }
2575 #endif
2576
2577
2578
2579 }
2580
2581 /*******************************************************************************
2582 **
2583 ** Function bta_hl_set_dch_chan_cfg
2584 **
2585 ** Description This function setups the L2CAP DCH channel configuration
2586 **
2587 ** Returns void
2588 *******************************************************************************/
bta_hl_set_dch_chan_cfg(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdl_idx,tBTA_HL_DATA * p_data)2589 void bta_hl_set_dch_chan_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,tBTA_HL_DATA *p_data)
2590 {
2591 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2592 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2593 UINT8 l2cap_mode = L2CAP_FCR_ERTM_MODE;
2594 tBTA_HL_SUP_FEATURE *p_sup_feature= &p_acb->sup_feature;
2595 UINT8 local_mdep_cfg_idx = p_dcb->local_mdep_cfg_idx;
2596
2597 switch (p_dcb->dch_oper)
2598 {
2599 case BTA_HL_DCH_OP_LOCAL_RECONNECT:
2600 case BTA_HL_DCH_OP_REMOTE_RECONNECT:
2601 if (p_dcb->dch_mode == BTA_HL_DCH_MODE_STREAMING)
2602 l2cap_mode = L2CAP_FCR_STREAM_MODE;
2603 break;
2604 case BTA_HL_DCH_OP_LOCAL_OPEN:
2605 if (p_data->mca_evt.mca_data.create_cfm.cfg == BTA_HL_DCH_CFG_STREAMING)
2606 l2cap_mode = L2CAP_FCR_STREAM_MODE;
2607 break;
2608 case BTA_HL_DCH_OP_REMOTE_OPEN:
2609 if (p_dcb->local_cfg == BTA_HL_DCH_CFG_STREAMING )
2610 l2cap_mode = L2CAP_FCR_STREAM_MODE;
2611 break;
2612 default:
2613 APPL_TRACE_ERROR1("Invalid dch oper=%d for set dch chan cfg", p_dcb->dch_oper);
2614 break;
2615 }
2616 p_dcb->chnl_cfg.fcr_opt.mode = l2cap_mode;
2617 p_dcb->chnl_cfg.fcr_opt.mps = bta_hl_set_mps(p_dcb->max_rx_apdu_size);
2618 p_dcb->chnl_cfg.fcr_opt.tx_win_sz = bta_hl_set_tx_win_size(p_dcb->max_rx_apdu_size,
2619 p_dcb->chnl_cfg.fcr_opt.mps);
2620 p_dcb->chnl_cfg.fcr_opt.max_transmit= BTA_HL_L2C_MAX_TRANSMIT;
2621 p_dcb->chnl_cfg.fcr_opt.rtrans_tout = BTA_HL_L2C_RTRANS_TOUT;
2622 p_dcb->chnl_cfg.fcr_opt.mon_tout = BTA_HL_L2C_MON_TOUT;
2623
2624 p_dcb->chnl_cfg.user_rx_pool_id = bta_hl_set_user_rx_pool_id(p_dcb->max_rx_apdu_size);
2625 p_dcb->chnl_cfg.user_tx_pool_id = bta_hl_set_user_tx_pool_id(p_dcb->max_tx_apdu_size);
2626 p_dcb->chnl_cfg.fcr_rx_pool_id = BTA_HL_L2C_FCR_RX_POOL_ID;
2627 p_dcb->chnl_cfg.fcr_tx_pool_id = BTA_HL_L2C_FCR_TX_POOL_ID;
2628 p_dcb->chnl_cfg.data_mtu = p_dcb->max_rx_apdu_size;
2629
2630 p_dcb->chnl_cfg.fcs = BTA_HL_MCA_NO_FCS;
2631 if (local_mdep_cfg_idx != BTA_HL_ECHO_TEST_MDEP_CFG_IDX)
2632 {
2633 if (p_sup_feature->mdep[local_mdep_cfg_idx].mdep_cfg.mdep_role ==
2634 BTA_HL_MDEP_ROLE_SOURCE)
2635 {
2636 p_dcb->chnl_cfg.fcs = BTA_HL_DEFAULT_SOURCE_FCS;
2637 }
2638 }
2639 else
2640 {
2641 p_dcb->chnl_cfg.fcs = BTA_HL_MCA_USE_FCS;
2642 }
2643
2644 #if BTA_HL_DEBUG == TRUE
2645 APPL_TRACE_DEBUG1("L2CAP Params l2cap_mode[3-ERTM 4-STREAM]=%d", l2cap_mode);
2646 APPL_TRACE_DEBUG2("Use FCS =%s mtu=%d", ((p_dcb->chnl_cfg.fcs & 1)?"YES":"NO"),
2647 p_dcb->chnl_cfg.data_mtu);
2648 APPL_TRACE_DEBUG5("tx_win_sz=%d, max_transmit=%d, rtrans_tout=%d, mon_tout=%d, mps=%d",
2649 p_dcb->chnl_cfg.fcr_opt.tx_win_sz,
2650 p_dcb->chnl_cfg.fcr_opt.max_transmit,
2651 p_dcb->chnl_cfg.fcr_opt.rtrans_tout,
2652 p_dcb->chnl_cfg.fcr_opt.mon_tout,
2653 p_dcb->chnl_cfg.fcr_opt.mps);
2654
2655 APPL_TRACE_DEBUG4("USER rx_pool_id=%d, tx_pool_id=%d, FCR rx_pool_id=%d, tx_pool_id=%d",
2656 p_dcb->chnl_cfg.user_rx_pool_id,
2657 p_dcb->chnl_cfg.user_tx_pool_id,
2658 p_dcb->chnl_cfg.fcr_rx_pool_id,
2659 p_dcb->chnl_cfg.fcr_tx_pool_id);
2660
2661 #endif
2662
2663
2664
2665
2666
2667
2668
2669
2670 }
2671
2672 /*******************************************************************************
2673 **
2674 ** Function bta_hl_get_l2cap_cfg
2675 **
2676 ** Description This function get the current L2CAP channel configuration
2677 **
2678 ** Returns BOOLEAN - TRUE - operation is successful
2679 *******************************************************************************/
bta_hl_get_l2cap_cfg(tBTA_HL_MDL_HANDLE mdl_hnd,tBTA_HL_L2CAP_CFG_INFO * p_cfg)2680 BOOLEAN bta_hl_get_l2cap_cfg(tBTA_HL_MDL_HANDLE mdl_hnd, tBTA_HL_L2CAP_CFG_INFO *p_cfg)
2681 {
2682 BOOLEAN success = FALSE;
2683 UINT16 lcid;
2684 tL2CAP_CFG_INFO *p_our_cfg;
2685 tL2CAP_CH_CFG_BITS our_cfg_bits;
2686 tL2CAP_CFG_INFO *p_peer_cfg;
2687 tL2CAP_CH_CFG_BITS peer_cfg_bits;
2688
2689 lcid = MCA_GetL2CapChannel((tMCA_DL) mdl_hnd);
2690 if ( lcid &&
2691 L2CA_GetCurrentConfig(lcid, &p_our_cfg, &our_cfg_bits, &p_peer_cfg,
2692 &peer_cfg_bits))
2693 {
2694 p_cfg->fcs = BTA_HL_MCA_NO_FCS;
2695 if (our_cfg_bits & L2CAP_CH_CFG_MASK_FCS)
2696 {
2697 p_cfg->fcs |= p_our_cfg->fcs;
2698 }
2699 else
2700 {
2701 p_cfg->fcs = BTA_HL_MCA_USE_FCS;
2702 }
2703
2704 if (p_cfg->fcs != BTA_HL_MCA_USE_FCS )
2705 {
2706 if (peer_cfg_bits & L2CAP_CH_CFG_MASK_FCS)
2707 {
2708 p_cfg->fcs |= p_peer_cfg->fcs;
2709 }
2710 else
2711 {
2712 p_cfg->fcs = BTA_HL_MCA_USE_FCS;
2713 }
2714 }
2715
2716 p_cfg->mtu =0;
2717 if (peer_cfg_bits & L2CAP_CH_CFG_MASK_MTU)
2718 {
2719 p_cfg->mtu = p_peer_cfg->mtu;
2720 }
2721 else
2722 {
2723 p_cfg->mtu = L2CAP_DEFAULT_MTU;
2724 }
2725 success = TRUE;
2726 }
2727
2728 #if BTA_HL_DEBUG == TRUE
2729 if (!success)
2730 {
2731 APPL_TRACE_DEBUG3("bta_hl_get_l2cap_cfg success=%d mdl=%d lcid=%d", success, mdl_hnd, lcid);
2732 APPL_TRACE_DEBUG2("l2cap mtu=%d fcs=%d", p_cfg->mtu, p_cfg->fcs);
2733 }
2734 #endif
2735
2736 return success;
2737 }
2738
2739 /*******************************************************************************
2740 **
2741 ** Function bta_hl_validate_chan_cfg
2742 **
2743 ** Description This function validates the L2CAP channel configuration
2744 **
2745 ** Returns BOOLEAN - TRUE - validation is successful
2746 *******************************************************************************/
bta_hl_validate_chan_cfg(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdl_idx)2747 BOOLEAN bta_hl_validate_chan_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx)
2748 {
2749 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2750 tBTA_HL_MDL_CB *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2751 BOOLEAN success = FALSE;
2752 UINT8 mdl_cfg_idx = 0;
2753 tBTA_HL_L2CAP_CFG_INFO l2cap_cfg;
2754 BOOLEAN get_l2cap_result, get_mdl_result;
2755
2756 get_l2cap_result = bta_hl_get_l2cap_cfg(p_dcb->mdl_handle, &l2cap_cfg);
2757 get_mdl_result = bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, p_dcb->mdl_id, &mdl_cfg_idx);
2758
2759 if (get_l2cap_result && get_mdl_result)
2760 {
2761 if ((p_acb->mdl_cfg[mdl_cfg_idx].mtu <= l2cap_cfg.mtu) &&
2762 (p_acb->mdl_cfg[mdl_cfg_idx].fcs == l2cap_cfg.fcs) &&
2763 (p_acb->mdl_cfg[mdl_cfg_idx].dch_mode == p_dcb->dch_mode))
2764 {
2765 success = TRUE;
2766 }
2767 }
2768
2769
2770 #if BTA_HL_DEBUG == TRUE
2771
2772 if (p_dcb->mtu != l2cap_cfg.mtu)
2773 {
2774 APPL_TRACE_WARNING2("MCAP and L2CAP peer mtu size out of sync from MCAP mtu=%d from l2cap mtu=%d",
2775 p_dcb->mtu, l2cap_cfg.mtu);
2776 }
2777
2778 if (!success)
2779 {
2780 APPL_TRACE_DEBUG4("bta_hl_validate_chan_cfg success=%d app_idx=%d mcl_idx=%d mdl_idx=%d",success, app_idx, mcl_idx, mdl_idx);
2781 APPL_TRACE_DEBUG3("Cur. L2cap cfg mtu=%d fcs=%d dch_mode=%d", l2cap_cfg.mtu, l2cap_cfg.fcs, p_dcb->dch_mode);
2782 APPL_TRACE_DEBUG3("From saved: L2cap cfg mtu=%d fcs=%d dch_mode=%d", p_acb->mdl_cfg[mdl_cfg_idx].mtu,
2783 p_acb->mdl_cfg[mdl_cfg_idx].fcs , p_acb->mdl_cfg[mdl_cfg_idx].dch_mode);
2784 }
2785 #endif
2786
2787 return success;
2788 }
2789
2790
2791 /*******************************************************************************
2792 **
2793 ** Function bta_hl_is_cong_on
2794 **
2795 ** Description This function checks whether the congestion condition is on or not
2796 **
2797 ** Returns BOOLEAN - TRUE DCH is congested
2798 ** FALSE not congested
2799 **
2800 *******************************************************************************/
bta_hl_is_cong_on(UINT8 app_id,BD_ADDR bd_addr,tBTA_HL_MDL_ID mdl_id)2801 BOOLEAN bta_hl_is_cong_on(UINT8 app_id, BD_ADDR bd_addr, tBTA_HL_MDL_ID mdl_id)
2802
2803 {
2804 tBTA_HL_MDL_CB *p_dcb;
2805 UINT8 app_idx = 0, mcl_idx, mdl_idx;
2806 BOOLEAN cong_status = TRUE;
2807
2808 if (bta_hl_find_app_idx(app_id, &app_idx))
2809 {
2810 if (bta_hl_find_mcl_idx(app_idx, bd_addr, &mcl_idx ))
2811 {
2812 if (bta_hl_find_mdl_idx(app_idx, mcl_idx, mdl_id, &mdl_idx ))
2813 {
2814 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2815 cong_status = p_dcb->cong;
2816 }
2817 }
2818 }
2819
2820 return cong_status;
2821 }
2822
2823 /*******************************************************************************
2824 **
2825 ** Function bta_hl_check_cch_close
2826 **
2827 ** Description This function checks whether there is a pending CCH close request
2828 ** or not
2829 **
2830 ** Returns void
2831 *******************************************************************************/
bta_hl_check_cch_close(UINT8 app_idx,UINT8 mcl_idx,tBTA_HL_DATA * p_data,BOOLEAN check_dch_setup)2832 void bta_hl_check_cch_close(UINT8 app_idx, UINT8 mcl_idx, tBTA_HL_DATA *p_data, BOOLEAN check_dch_setup )
2833 {
2834 tBTA_HL_MCL_CB *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2835 tBTA_HL_MDL_CB *p_dcb;
2836 UINT8 mdl_idx;
2837
2838 #if (BTA_HL_DEBUG == TRUE)
2839 APPL_TRACE_DEBUG1("bta_hl_check_cch_close cch_close_dch_oper=%d",p_mcb->cch_close_dch_oper );
2840 #endif
2841
2842 if (p_mcb->cch_oper == BTA_HL_CCH_OP_LOCAL_CLOSE)
2843 {
2844 if (check_dch_setup && bta_hl_find_dch_setup_mdl_idx(app_idx, mcl_idx, &mdl_idx))
2845 {
2846 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2847 if (!p_mcb->rsp_tout)
2848 {
2849 p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_ABORT;
2850
2851 if (!p_dcb->abort_oper)
2852 {
2853 p_dcb->abort_oper |= BTA_HL_ABORT_CCH_CLOSE_MASK;
2854 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_ABORT_EVT, p_data);
2855 }
2856 }
2857 else
2858 {
2859 p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_CLOSE;
2860 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
2861 }
2862 }
2863 else if (bta_hl_find_an_active_mdl_idx(app_idx, mcl_idx,&mdl_idx))
2864 {
2865 p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_CLOSE;
2866 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_EVT, p_data);
2867 }
2868 else
2869 {
2870 p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_NONE;
2871 bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_CLOSE_EVT, p_data);
2872 }
2873 }
2874 }
2875
2876 /*******************************************************************************
2877 **
2878 ** Function bta_hl_clean_app
2879 **
2880 ** Description Cleans up the HDP application resources and control block
2881 **
2882 ** Returns void
2883 **
2884 *******************************************************************************/
bta_hl_clean_app(UINT8 app_idx)2885 void bta_hl_clean_app(UINT8 app_idx)
2886 {
2887 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2888 int i, num_act_apps=0;
2889
2890 #if BTA_HL_DEBUG == TRUE
2891 APPL_TRACE_DEBUG0("bta_hl_clean_app");
2892 #endif
2893 MCA_Deregister((tMCA_HANDLE)p_acb->app_handle);
2894
2895 if (p_acb->sdp_handle) SDP_DeleteRecord(p_acb->sdp_handle);
2896
2897 memset((void *) p_acb, 0, sizeof(tBTA_HL_APP_CB));
2898
2899 /* check any application is still active */
2900 for (i=0; i < BTA_HL_NUM_APPS ; i ++)
2901 {
2902 p_acb = BTA_HL_GET_APP_CB_PTR(i);
2903 if (p_acb->in_use) num_act_apps++;
2904 }
2905
2906 if (!num_act_apps)
2907 {
2908 bta_sys_remove_uuid(UUID_SERVCLASS_HDP_PROFILE);
2909 }
2910 }
2911
2912 /*******************************************************************************
2913 **
2914 ** Function bta_hl_check_deregistration
2915 **
2916 ** Description This function checks whether there is a pending deregistration
2917 ** request or not
2918 **
2919 ** Returns void
2920 *******************************************************************************/
bta_hl_check_deregistration(UINT8 app_idx,tBTA_HL_DATA * p_data)2921 void bta_hl_check_deregistration(UINT8 app_idx, tBTA_HL_DATA *p_data )
2922 {
2923 tBTA_HL_APP_CB *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2924 tBTA_HL_MCL_CB *p_mcb;
2925 UINT8 mcl_idx;
2926 tBTA_HL evt_data;
2927
2928 #if (BTA_HL_DEBUG == TRUE)
2929 APPL_TRACE_DEBUG0("bta_hl_check_deregistration");
2930 #endif
2931
2932 if (p_acb->deregistering)
2933 {
2934 if (bta_hl_find_an_in_use_mcl_idx(app_idx, &mcl_idx))
2935 {
2936 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2937 if (p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_CLOSE)
2938 {
2939 if (p_mcb->cch_state == BTA_HL_CCH_OPENING_ST)
2940 p_mcb->force_close_local_cch_opening = TRUE;
2941 p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_CLOSE;
2942 APPL_TRACE_DEBUG1("p_mcb->force_close_local_cch_opening=%d", p_mcb->force_close_local_cch_opening );
2943 bta_hl_check_cch_close(app_idx,mcl_idx,p_data, TRUE);
2944 }
2945 }
2946 else
2947 {
2948 /* all cchs are closed */
2949 evt_data.dereg_cfm.app_handle = p_acb->app_handle;
2950 evt_data.dereg_cfm.app_id = p_data->api_dereg.app_id;
2951 evt_data.dereg_cfm.status = BTA_HL_STATUS_OK;
2952 p_acb->p_cback(BTA_HL_DEREGISTER_CFM_EVT, (tBTA_HL *) &evt_data );
2953 bta_hl_clean_app(app_idx);
2954 bta_hl_check_disable(p_data);
2955 }
2956 }
2957 }
2958
2959
2960 /*******************************************************************************
2961 **
2962 ** Function bta_hl_check_disable
2963 **
2964 ** Description This function checks whether there is a pending disable
2965 ** request or not
2966 **
2967 ** Returns void
2968 **
2969 *******************************************************************************/
bta_hl_check_disable(tBTA_HL_DATA * p_data)2970 void bta_hl_check_disable(tBTA_HL_DATA *p_data )
2971 {
2972 tBTA_HL_CB *p_cb= &bta_hl_cb;
2973 tBTA_HL_APP_CB *p_acb;
2974 UINT8 app_idx;
2975 tBTA_HL_CTRL evt_data;
2976
2977 #if (BTA_HL_DEBUG == TRUE)
2978 APPL_TRACE_DEBUG0("bta_hl_check_disable");
2979 #endif
2980
2981 if (bta_hl_cb.disabling)
2982 {
2983 if (bta_hl_find_an_in_use_app_idx(&app_idx))
2984 {
2985 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2986 if (!p_acb->deregistering)
2987 {
2988 p_acb->deregistering = TRUE;
2989 bta_hl_check_deregistration(app_idx, p_data);
2990 }
2991 }
2992 else
2993 {
2994 /* all apps are deregistered */
2995 bta_sys_deregister(BTA_ID_HL);
2996 evt_data.disable_cfm.status = BTA_HL_STATUS_OK;
2997 if (p_cb->p_ctrl_cback) p_cb->p_ctrl_cback(BTA_HL_CTRL_DISABLE_CFM_EVT, (tBTA_HL_CTRL *) &evt_data);
2998 memset((void *) p_cb, 0, sizeof(tBTA_HL_CB));
2999 }
3000 }
3001 }
3002
3003 /*******************************************************************************
3004 **
3005 ** Function bta_hl_build_abort_cfm
3006 **
3007 ** Description This function builds the abort confirmation event data
3008 **
3009 ** Returns None
3010 **
3011 *******************************************************************************/
bta_hl_build_abort_cfm(tBTA_HL * p_evt_data,tBTA_HL_APP_HANDLE app_handle,tBTA_HL_MCL_HANDLE mcl_handle,tBTA_HL_STATUS status)3012 void bta_hl_build_abort_cfm(tBTA_HL *p_evt_data,
3013 tBTA_HL_APP_HANDLE app_handle,
3014 tBTA_HL_MCL_HANDLE mcl_handle,
3015 tBTA_HL_STATUS status)
3016 {
3017 p_evt_data->dch_abort_cfm.status = status;
3018 p_evt_data->dch_abort_cfm.mcl_handle = mcl_handle;
3019 p_evt_data->dch_abort_cfm.app_handle = app_handle;
3020 }
3021
3022 /*******************************************************************************
3023 **
3024 ** Function bta_hl_build_abort_ind
3025 **
3026 ** Description This function builds the abort indication event data
3027 **
3028 ** Returns None
3029 **
3030 *******************************************************************************/
bta_hl_build_abort_ind(tBTA_HL * p_evt_data,tBTA_HL_APP_HANDLE app_handle,tBTA_HL_MCL_HANDLE mcl_handle)3031 void bta_hl_build_abort_ind(tBTA_HL *p_evt_data,
3032 tBTA_HL_APP_HANDLE app_handle,
3033 tBTA_HL_MCL_HANDLE mcl_handle)
3034 {
3035 p_evt_data->dch_abort_ind.mcl_handle = mcl_handle;
3036 p_evt_data->dch_abort_ind.app_handle = app_handle;
3037 }
3038 /*******************************************************************************
3039 **
3040 ** Function bta_hl_build_close_cfm
3041 **
3042 ** Description This function builds the close confirmation event data
3043 **
3044 ** Returns None
3045 **
3046 *******************************************************************************/
bta_hl_build_dch_close_cfm(tBTA_HL * p_evt_data,tBTA_HL_APP_HANDLE app_handle,tBTA_HL_MCL_HANDLE mcl_handle,tBTA_HL_MDL_HANDLE mdl_handle,tBTA_HL_STATUS status)3047 void bta_hl_build_dch_close_cfm(tBTA_HL *p_evt_data,
3048 tBTA_HL_APP_HANDLE app_handle,
3049 tBTA_HL_MCL_HANDLE mcl_handle,
3050 tBTA_HL_MDL_HANDLE mdl_handle,
3051 tBTA_HL_STATUS status)
3052 {
3053 p_evt_data->dch_close_cfm.status = status;
3054 p_evt_data->dch_close_cfm.mdl_handle = mdl_handle;
3055 p_evt_data->dch_close_cfm.mcl_handle = mcl_handle;
3056 p_evt_data->dch_close_cfm.app_handle = app_handle;
3057 }
3058
3059 /*******************************************************************************
3060 **
3061 ** Function bta_hl_build_dch_close_ind
3062 **
3063 ** Description This function builds the close indication event data
3064 **
3065 ** Returns None
3066 **
3067 *******************************************************************************/
bta_hl_build_dch_close_ind(tBTA_HL * p_evt_data,tBTA_HL_APP_HANDLE app_handle,tBTA_HL_MCL_HANDLE mcl_handle,tBTA_HL_MDL_HANDLE mdl_handle,BOOLEAN intentional)3068 void bta_hl_build_dch_close_ind(tBTA_HL *p_evt_data,
3069 tBTA_HL_APP_HANDLE app_handle,
3070 tBTA_HL_MCL_HANDLE mcl_handle,
3071 tBTA_HL_MDL_HANDLE mdl_handle,
3072 BOOLEAN intentional)
3073 {
3074 p_evt_data->dch_close_ind.mdl_handle = mdl_handle;
3075 p_evt_data->dch_close_ind.mcl_handle = mcl_handle;
3076 p_evt_data->dch_close_ind.app_handle = app_handle;
3077 p_evt_data->dch_close_ind.intentional = intentional;
3078 }
3079
3080 /*******************************************************************************
3081 **
3082 ** Function bta_hl_build_send_data_cfm
3083 **
3084 ** Description This function builds the send data confirmation event data
3085 **
3086 ** Returns None
3087 **
3088 *******************************************************************************/
bta_hl_build_send_data_cfm(tBTA_HL * p_evt_data,tBTA_HL_APP_HANDLE app_handle,tBTA_HL_MCL_HANDLE mcl_handle,tBTA_HL_MDL_HANDLE mdl_handle,tBTA_HL_STATUS status)3089 void bta_hl_build_send_data_cfm(tBTA_HL *p_evt_data,
3090 tBTA_HL_APP_HANDLE app_handle,
3091 tBTA_HL_MCL_HANDLE mcl_handle,
3092 tBTA_HL_MDL_HANDLE mdl_handle,
3093 tBTA_HL_STATUS status )
3094 {
3095
3096 p_evt_data->dch_send_data_cfm.mdl_handle = mdl_handle;
3097 p_evt_data->dch_send_data_cfm.mcl_handle = mcl_handle;
3098 p_evt_data->dch_send_data_cfm.app_handle = app_handle;
3099 p_evt_data->dch_send_data_cfm.status = status;
3100 }
3101
3102 /*******************************************************************************
3103 **
3104 ** Function bta_hl_build_rcv_data_ind
3105 **
3106 ** Description This function builds the received data indication event data
3107 **
3108 ** Returns None
3109 **
3110 *******************************************************************************/
bta_hl_build_rcv_data_ind(tBTA_HL * p_evt_data,tBTA_HL_APP_HANDLE app_handle,tBTA_HL_MCL_HANDLE mcl_handle,tBTA_HL_MDL_HANDLE mdl_handle)3111 void bta_hl_build_rcv_data_ind(tBTA_HL *p_evt_data,
3112 tBTA_HL_APP_HANDLE app_handle,
3113 tBTA_HL_MCL_HANDLE mcl_handle,
3114 tBTA_HL_MDL_HANDLE mdl_handle)
3115 {
3116 p_evt_data->dch_rcv_data_ind.mdl_handle = mdl_handle;
3117 p_evt_data->dch_rcv_data_ind.mcl_handle = mcl_handle;
3118 p_evt_data->dch_rcv_data_ind.app_handle = app_handle;
3119 }
3120
3121
3122 /*******************************************************************************
3123 **
3124 ** Function bta_hl_build_cch_open_cfm
3125 **
3126 ** Description This function builds the CCH open confirmation event data
3127 **
3128 ** Returns None
3129 **
3130 *******************************************************************************/
bta_hl_build_cch_open_cfm(tBTA_HL * p_evt_data,UINT8 app_id,tBTA_HL_APP_HANDLE app_handle,tBTA_HL_MCL_HANDLE mcl_handle,BD_ADDR bd_addr,tBTA_HL_STATUS status)3131 void bta_hl_build_cch_open_cfm(tBTA_HL *p_evt_data,
3132 UINT8 app_id,
3133 tBTA_HL_APP_HANDLE app_handle,
3134 tBTA_HL_MCL_HANDLE mcl_handle,
3135 BD_ADDR bd_addr,
3136 tBTA_HL_STATUS status )
3137 {
3138 p_evt_data->cch_open_cfm.app_id = app_id;
3139 p_evt_data->cch_open_cfm.app_handle = app_handle;
3140 p_evt_data->cch_open_cfm.mcl_handle = mcl_handle;
3141 bdcpy(p_evt_data->cch_open_cfm.bd_addr, bd_addr);
3142 p_evt_data->cch_open_cfm.status = status;
3143 APPL_TRACE_DEBUG1("bta_hl_build_cch_open_cfm: status=%d",status);
3144 }
3145
3146 /*******************************************************************************
3147 **
3148 ** Function bta_hl_build_cch_open_ind
3149 **
3150 ** Description This function builds the CCH open indication event data
3151 **
3152 ** Returns None
3153 **
3154 *******************************************************************************/
bta_hl_build_cch_open_ind(tBTA_HL * p_evt_data,tBTA_HL_APP_HANDLE app_handle,tBTA_HL_MCL_HANDLE mcl_handle,BD_ADDR bd_addr)3155 void bta_hl_build_cch_open_ind(tBTA_HL *p_evt_data, tBTA_HL_APP_HANDLE app_handle,
3156 tBTA_HL_MCL_HANDLE mcl_handle,
3157 BD_ADDR bd_addr )
3158 {
3159
3160 p_evt_data->cch_open_ind.app_handle = app_handle;
3161 p_evt_data->cch_open_ind.mcl_handle = mcl_handle;
3162 bdcpy(p_evt_data->cch_open_ind.bd_addr, bd_addr);
3163 }
3164
3165 /*******************************************************************************
3166 **
3167 ** Function bta_hl_build_cch_close_cfm
3168 **
3169 ** Description This function builds the CCH close confirmation event data
3170 **
3171 ** Returns None
3172 **
3173 *******************************************************************************/
bta_hl_build_cch_close_cfm(tBTA_HL * p_evt_data,tBTA_HL_APP_HANDLE app_handle,tBTA_HL_MCL_HANDLE mcl_handle,tBTA_HL_STATUS status)3174 void bta_hl_build_cch_close_cfm(tBTA_HL *p_evt_data,
3175 tBTA_HL_APP_HANDLE app_handle,
3176 tBTA_HL_MCL_HANDLE mcl_handle,
3177 tBTA_HL_STATUS status )
3178 {
3179 p_evt_data->cch_close_cfm.mcl_handle = mcl_handle;
3180 p_evt_data->cch_close_cfm.app_handle = app_handle;
3181 p_evt_data->cch_close_cfm.status = status;
3182 }
3183
3184
3185 /*******************************************************************************
3186 **
3187 ** Function bta_hl_build_cch_close_ind
3188 **
3189 ** Description This function builds the CCH colse indication event data
3190 **
3191 ** Returns None
3192 **
3193 *******************************************************************************/
bta_hl_build_cch_close_ind(tBTA_HL * p_evt_data,tBTA_HL_APP_HANDLE app_handle,tBTA_HL_MCL_HANDLE mcl_handle,BOOLEAN intentional)3194 void bta_hl_build_cch_close_ind(tBTA_HL *p_evt_data,
3195 tBTA_HL_APP_HANDLE app_handle,
3196 tBTA_HL_MCL_HANDLE mcl_handle,
3197 BOOLEAN intentional)
3198 {
3199 p_evt_data->cch_close_ind.mcl_handle = mcl_handle;
3200 p_evt_data->cch_close_ind.app_handle = app_handle;
3201 p_evt_data->cch_close_ind.intentional = intentional;
3202 }
3203
3204 /*******************************************************************************
3205 **
3206 ** Function bta_hl_build_dch_open_cfm
3207 **
3208 ** Description This function builds the DCH open confirmation event data
3209 **
3210 ** Returns None
3211 **
3212 *******************************************************************************/
bta_hl_build_dch_open_cfm(tBTA_HL * p_evt_data,tBTA_HL_APP_HANDLE app_handle,tBTA_HL_MCL_HANDLE mcl_handle,tBTA_HL_MDL_HANDLE mdl_handle,tBTA_HL_MDEP_ID local_mdep_id,tBTA_HL_MDL_ID mdl_id,tBTA_HL_DCH_MODE dch_mode,BOOLEAN first_reliable,UINT16 mtu,tBTA_HL_STATUS status)3213 void bta_hl_build_dch_open_cfm(tBTA_HL *p_evt_data,
3214 tBTA_HL_APP_HANDLE app_handle,
3215 tBTA_HL_MCL_HANDLE mcl_handle,
3216 tBTA_HL_MDL_HANDLE mdl_handle,
3217 tBTA_HL_MDEP_ID local_mdep_id,
3218 tBTA_HL_MDL_ID mdl_id,
3219 tBTA_HL_DCH_MODE dch_mode,
3220 BOOLEAN first_reliable,
3221 UINT16 mtu,
3222 tBTA_HL_STATUS status)
3223
3224 {
3225 p_evt_data->dch_open_cfm.mdl_handle = mdl_handle;
3226 p_evt_data->dch_open_cfm.mcl_handle = mcl_handle;
3227 p_evt_data->dch_open_cfm.app_handle = app_handle;
3228 p_evt_data->dch_open_cfm.local_mdep_id = local_mdep_id;
3229 p_evt_data->dch_open_cfm.mdl_id = mdl_id;
3230 p_evt_data->dch_open_cfm.dch_mode = dch_mode;
3231 p_evt_data->dch_open_cfm.first_reliable = first_reliable;
3232 p_evt_data->dch_open_cfm.mtu = mtu;
3233 p_evt_data->dch_open_cfm.status = status;
3234 }
3235
3236
3237 /*******************************************************************************
3238 **
3239 ** Function bta_hl_build_sdp_query_cfm
3240 **
3241 ** Description This function builds the SDP query indication event data
3242 **
3243 ** Returns None
3244 **
3245 *******************************************************************************/
bta_hl_build_sdp_query_cfm(tBTA_HL * p_evt_data,UINT8 app_id,tBTA_HL_APP_HANDLE app_handle,BD_ADDR bd_addr,tBTA_HL_SDP * p_sdp,tBTA_HL_STATUS status)3246 void bta_hl_build_sdp_query_cfm(tBTA_HL *p_evt_data,
3247 UINT8 app_id,
3248 tBTA_HL_APP_HANDLE app_handle,
3249 BD_ADDR bd_addr,
3250 tBTA_HL_SDP *p_sdp,
3251 tBTA_HL_STATUS status)
3252
3253 {
3254 APPL_TRACE_DEBUG2("bta_hl_build_sdp_query_cfm: app_id = %d, app_handle=%d",
3255 app_id,app_handle);
3256 p_evt_data->sdp_query_cfm.app_id = app_id;
3257 p_evt_data->sdp_query_cfm.app_handle = app_handle;
3258 bdcpy(p_evt_data->sdp_query_cfm.bd_addr, bd_addr);
3259 p_evt_data->sdp_query_cfm.p_sdp = p_sdp;
3260 p_evt_data->sdp_query_cfm.status = status;
3261 }
3262
3263
3264 /*******************************************************************************
3265 **
3266 ** Function bta_hl_build_delete_mdl_cfm
3267 **
3268 ** Description This function builds the delete MDL confirmation event data
3269 **
3270 ** Returns None
3271 **
3272 *******************************************************************************/
bta_hl_build_delete_mdl_cfm(tBTA_HL * p_evt_data,tBTA_HL_APP_HANDLE app_handle,tBTA_HL_MCL_HANDLE mcl_handle,tBTA_HL_MDL_ID mdl_id,tBTA_HL_STATUS status)3273 void bta_hl_build_delete_mdl_cfm(tBTA_HL *p_evt_data,
3274 tBTA_HL_APP_HANDLE app_handle,
3275 tBTA_HL_MCL_HANDLE mcl_handle,
3276 tBTA_HL_MDL_ID mdl_id,
3277 tBTA_HL_STATUS status)
3278
3279 {
3280 p_evt_data->delete_mdl_cfm.mcl_handle = mcl_handle;
3281 p_evt_data->delete_mdl_cfm.app_handle = app_handle;
3282 p_evt_data->delete_mdl_cfm.mdl_id = mdl_id;
3283 p_evt_data->delete_mdl_cfm.status = status;
3284 }
3285
3286 /*******************************************************************************
3287 **
3288 ** Function bta_hl_build_echo_test_cfm
3289 **
3290 ** Description This function builds the echo test confirmation event data
3291 **
3292 ** Returns None
3293 **
3294 *******************************************************************************/
bta_hl_build_echo_test_cfm(tBTA_HL * p_evt_data,tBTA_HL_APP_HANDLE app_handle,tBTA_HL_MCL_HANDLE mcl_handle,tBTA_HL_STATUS status)3295 void bta_hl_build_echo_test_cfm(tBTA_HL *p_evt_data,
3296 tBTA_HL_APP_HANDLE app_handle,
3297 tBTA_HL_MCL_HANDLE mcl_handle,
3298 tBTA_HL_STATUS status )
3299 {
3300 p_evt_data->echo_test_cfm.mcl_handle = mcl_handle;
3301 p_evt_data->echo_test_cfm.app_handle = app_handle;
3302 p_evt_data->echo_test_cfm.status = status;
3303 }
3304
3305
3306 /*****************************************************************************
3307 ** Debug Functions
3308 *****************************************************************************/
3309 #if (BTA_HL_DEBUG == TRUE)
3310
3311 /*******************************************************************************
3312 **
3313 ** Function bta_hl_status_code
3314 **
3315 ** Description get the status string pointer
3316 **
3317 ** Returns char * - status string pointer
3318 **
3319 *******************************************************************************/
bta_hl_status_code(tBTA_HL_STATUS status)3320 char *bta_hl_status_code(tBTA_HL_STATUS status)
3321 {
3322 switch (status)
3323 {
3324 case BTA_HL_STATUS_OK:
3325 return "BTA_HL_STATUS_OK";
3326 case BTA_HL_STATUS_FAIL:
3327 return "BTA_HL_STATUS_FAIL";
3328 case BTA_HL_STATUS_ABORTED:
3329 return "BTA_HL_STATUS_ABORTED";
3330 case BTA_HL_STATUS_NO_RESOURCE:
3331 return "BTA_HL_STATUS_NO_RESOURCE";
3332 case BTA_HL_STATUS_LAST_ITEM:
3333 return "BTA_HL_STATUS_LAST_ITEM";
3334 case BTA_HL_STATUS_DUPLICATE_APP_ID:
3335 return "BTA_HL_STATUS_DUPLICATE_APP_ID";
3336 case BTA_HL_STATUS_INVALID_APP_HANDLE:
3337 return "BTA_HL_STATUS_INVALID_APP_HANDLE";
3338 case BTA_HL_STATUS_INVALID_MCL_HANDLE:
3339 return "BTA_HL_STATUS_INVALID_MCL_HANDLE";
3340 case BTA_HL_STATUS_MCAP_REG_FAIL:
3341 return "BTA_HL_STATUS_MCAP_REG_FAIL";
3342 case BTA_HL_STATUS_MDEP_CO_FAIL:
3343 return "BTA_HL_STATUS_MDEP_CO_FAIL";
3344 case BTA_HL_STATUS_ECHO_CO_FAIL:
3345 return "BTA_HL_STATUS_ECHO_CO_FAIL";
3346 case BTA_HL_STATUS_MDL_CFG_CO_FAIL:
3347 return "BTA_HL_STATUS_MDL_CFG_CO_FAIL";
3348 case BTA_HL_STATUS_SDP_NO_RESOURCE:
3349 return "BTA_HL_STATUS_SDP_NO_RESOURCE";
3350 case BTA_HL_STATUS_SDP_FAIL:
3351 return "BTA_HL_STATUS_SDP_FAIL";
3352 case BTA_HL_STATUS_NO_CCH:
3353 return "BTA_HL_STATUS_NO_CCH";
3354 case BTA_HL_STATUS_NO_MCL:
3355 return "BTA_HL_STATUS_NO_MCL";
3356
3357 case BTA_HL_STATUS_NO_FIRST_RELIABLE:
3358 return "BTA_HL_STATUS_NO_FIRST_RELIABLE";
3359 case BTA_HL_STATUS_INVALID_DCH_CFG:
3360 return "BTA_HL_STATUS_INVALID_DCH_CFG";
3361 case BTA_HL_STATUS_INVALID_BD_ADDR:
3362 return "BTA_HL_STATUS_INVALID_BD_ADDR";
3363 case BTA_HL_STATUS_INVALID_RECONNECT_CFG:
3364 return "BTA_HL_STATUS_INVALID_RECONNECT_CFG";
3365 case BTA_HL_STATUS_ECHO_TEST_BUSY:
3366 return "BTA_HL_STATUS_ECHO_TEST_BUSY";
3367 case BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID:
3368 return "BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID";
3369 case BTA_HL_STATUS_INVALID_MDL_ID:
3370 return "BTA_HL_STATUS_INVALID_MDL_ID";
3371 case BTA_HL_STATUS_NO_MDL_ID_FOUND:
3372 return "BTA_HL_STATUS_NO_MDL_ID_FOUND";
3373 case BTA_HL_STATUS_DCH_BUSY:
3374 return "BTA_HL_STATUS_DCH_BUSY";
3375 default:
3376 return "Unknown status code";
3377 }
3378 }
3379 /*******************************************************************************
3380 **
3381 ** Function bta_hl_evt_code
3382 **
3383 ** Description Maps HL event code to the corresponding event string
3384 **
3385 ** Returns string pointer for the associated event name
3386 **
3387 *******************************************************************************/
bta_hl_evt_code(tBTA_HL_INT_EVT evt_code)3388 char *bta_hl_evt_code(tBTA_HL_INT_EVT evt_code)
3389 {
3390 switch (evt_code)
3391 {
3392 case BTA_HL_CCH_OPEN_EVT:
3393 return "BTA_HL_CCH_OPEN_EVT";
3394 case BTA_HL_CCH_SDP_OK_EVT:
3395 return "BTA_HL_CCH_SDP_OK_EVT";
3396 case BTA_HL_CCH_SDP_FAIL_EVT:
3397 return "BTA_HL_CCH_SDP_FAIL_EVT";
3398 case BTA_HL_MCA_CONNECT_IND_EVT:
3399 return "BTA_HL_MCA_CONNECT_IND_EVT";
3400 case BTA_HL_MCA_DISCONNECT_IND_EVT:
3401 return "BTA_HL_MCA_DISCONNECT_IND_EVT";
3402
3403 case BTA_HL_CCH_CLOSE_EVT:
3404 return "BTA_HL_CCH_CLOSE_EVT";
3405 case BTA_HL_CCH_CLOSE_CMPL_EVT:
3406 return "BTA_HL_CCH_CLOSE_CMPL_EVT";
3407 case BTA_HL_DCH_OPEN_EVT:
3408 return "BTA_HL_DCH_OPEN_EVT";
3409 case BTA_HL_MCA_CREATE_IND_EVT:
3410 return "BTA_HL_MCA_CREATE_IND_EVT";
3411 case BTA_HL_MCA_CREATE_CFM_EVT:
3412 return "BTA_HL_MCA_CREATE_CFM_EVT";
3413 case BTA_HL_MCA_OPEN_IND_EVT:
3414 return "BTA_HL_MCA_OPEN_IND_EVT";
3415 case BTA_HL_MCA_OPEN_CFM_EVT:
3416 return "BTA_HL_MCA_OPEN_CFM_EVT";
3417 case BTA_HL_DCH_CLOSE_EVT:
3418 return "BTA_HL_DCH_CLOSE_EVT";
3419 case BTA_HL_MCA_CLOSE_IND_EVT:
3420 return "BTA_HL_MCA_CLOSE_IND_EVT";
3421 case BTA_HL_MCA_CLOSE_CFM_EVT:
3422 return "BTA_HL_MCA_CLOSE_CFM_EVT";
3423 case BTA_HL_API_SEND_DATA_EVT:
3424 return "BTA_HL_API_SEND_DATA_EVT";
3425 case BTA_HL_MCA_RCV_DATA_EVT:
3426 return "BTA_HL_MCA_RCV_DATA_EVT";
3427 case BTA_HL_DCH_CLOSE_CMPL_EVT:
3428 return "BTA_HL_DCH_CLOSE_CMPL_EVT";
3429
3430 case BTA_HL_API_ENABLE_EVT:
3431 return "BTA_HL_API_ENABLE_EVT";
3432 case BTA_HL_API_DISABLE_EVT:
3433 return "BTA_HL_API_DISABLE_EVT";
3434 case BTA_HL_API_UPDATE_EVT:
3435 return "BTA_HL_API_UPDATE_EVT";
3436 case BTA_HL_API_REGISTER_EVT:
3437 return "BTA_HL_API_REGISTER_EVT";
3438 case BTA_HL_API_DEREGISTER_EVT:
3439 return "BTA_HL_API_DEREGISTER_EVT";
3440
3441 case BTA_HL_API_CCH_OPEN_EVT:
3442 return "BTA_HL_API_CCH_OPEN_EVT";
3443
3444 case BTA_HL_API_CCH_CLOSE_EVT:
3445 return "BTA_HL_API_CCH_CLOSE_EVT";
3446 case BTA_HL_API_DCH_OPEN_EVT:
3447 return "BTA_HL_API_DCH_OPEN_EVT";
3448
3449 case BTA_HL_API_DCH_RECONNECT_EVT:
3450 return "BTA_HL_API_DCH_RECONNECT_EVT";
3451 case BTA_HL_API_DCH_CLOSE_EVT:
3452 return "BTA_HL_API_DCH_CLOSE_EVT";
3453 case BTA_HL_API_DELETE_MDL_EVT:
3454 return "BTA_HL_API_DELETE_MDL_EVT";
3455 case BTA_HL_API_DCH_ABORT_EVT:
3456 return "BTA_HL_API_DCH_ABORT_EVT";
3457
3458 case BTA_HL_DCH_RECONNECT_EVT:
3459 return "BTA_HL_DCH_RECONNECT_EVT";
3460 case BTA_HL_DCH_SDP_INIT_EVT:
3461 return "BTA_HL_DCH_SDP_INIT_EVT";
3462 case BTA_HL_DCH_SDP_FAIL_EVT:
3463 return "BTA_HL_DCH_SDP_FAIL_EVT";
3464 case BTA_HL_API_DCH_ECHO_TEST_EVT:
3465 return "BTA_HL_API_DCH_ECHO_TEST_EVT";
3466 case BTA_HL_DCH_CLOSE_ECHO_TEST_EVT:
3467 return "BTA_HL_DCH_CLOSE_ECHO_TEST_EVT";
3468 case BTA_HL_MCA_RECONNECT_IND_EVT:
3469 return "BTA_HL_MCA_RECONNECT_IND_EVT";
3470 case BTA_HL_MCA_RECONNECT_CFM_EVT:
3471 return "BTA_HL_MCA_RECONNECT_CFM_EVT";
3472 case BTA_HL_API_DCH_CREATE_RSP_EVT:
3473 return "BTA_HL_API_DCH_CREATE_RSP_EVT";
3474 case BTA_HL_DCH_ABORT_EVT:
3475 return "BTA_HL_DCH_ABORT_EVT";
3476 case BTA_HL_MCA_ABORT_IND_EVT:
3477 return "BTA_HL_MCA_ABORT_IND_EVT";
3478 case BTA_HL_MCA_ABORT_CFM_EVT:
3479 return "BTA_HL_MCA_ABORT_CFM_EVT";
3480 case BTA_HL_MCA_DELETE_IND_EVT:
3481 return "BTA_HL_MCA_DELETE_IND_EVT";
3482 case BTA_HL_MCA_DELETE_CFM_EVT:
3483 return "BTA_HL_MCA_DELETE_CFM_EVT";
3484 case BTA_HL_MCA_CONG_CHG_EVT:
3485 return "BTA_HL_MCA_CONG_CHG_EVT";
3486 case BTA_HL_CI_GET_TX_DATA_EVT:
3487 return "BTA_HL_CI_GET_TX_DATA_EVT";
3488 case BTA_HL_CI_PUT_RX_DATA_EVT:
3489 return "BTA_HL_CI_PUT_RX_DATA_EVT";
3490 case BTA_HL_CI_GET_ECHO_DATA_EVT:
3491 return "BTA_HL_CI_GET_ECHO_DATA_EVT";
3492 case BTA_HL_DCH_ECHO_TEST_EVT:
3493 return "BTA_HL_DCH_ECHO_TEST_EVT";
3494 case BTA_HL_CI_PUT_ECHO_DATA_EVT:
3495 return "BTA_HL_CI_PUT_ECHO_DATA_EVT";
3496 case BTA_HL_API_SDP_QUERY_EVT:
3497 return "BTA_HL_API_SDP_QUERY_EVT";
3498 case BTA_HL_SDP_QUERY_OK_EVT:
3499 return "BTA_HL_SDP_QUERY_OK_EVT";
3500 case BTA_HL_SDP_QUERY_FAIL_EVT:
3501 return "BTA_HL_SDP_QUERY_FAIL_EVT";
3502 case BTA_HL_MCA_RSP_TOUT_IND_EVT:
3503 return "BTA_HL_MCA_RSP_TOUT_IND_EVT";
3504
3505 default:
3506 return "Unknown HL event code";
3507 }
3508 }
3509
3510 #endif /* Debug Functions */
3511 #endif // HL_INCLUDED
3512
3513
3514
3515
3516
3517
3518
3519
3520