• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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, mcl_idx;
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)
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)
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, mcl_idx, mdl_idx;
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,j;
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             (!memcmp (p_mcb->bd_addr, p_mdl->peer_bd_addr, BD_ADDR_LEN))&&
1469             (p_mdl->mdl_id == mdl_id))
1470         {
1471             found=TRUE;
1472             *p_mdl_cfg_idx =i;
1473             break;
1474         }
1475     }
1476 
1477 #if BTA_HL_DEBUG == TRUE
1478     if (!found)
1479     {
1480         APPL_TRACE_DEBUG2("bta_hl_find_mdl_cfg_idx found=%d mdl_cfg_idx=%d ",found, i );
1481     }
1482 #endif
1483 
1484     return found;
1485 
1486 
1487 }
1488 
1489 
1490 /*******************************************************************************
1491 **
1492 ** Function      bta_hl_get_cur_time
1493 **
1494 ** Description  This function get the cuurent time value
1495 **
1496 ** Returns      BOOLEAN - TRUE found
1497 **                        FALSE not found
1498 **
1499 *******************************************************************************/
bta_hl_get_cur_time(UINT8 app_idx,UINT8 * p_cur_time)1500 BOOLEAN  bta_hl_get_cur_time(UINT8 app_idx, UINT8 *p_cur_time)
1501 {
1502     tBTA_HL_MDL_CFG     *p_mdl;
1503     UINT8 i, j, time_latest, time;
1504     BOOLEAN found=FALSE, result=TRUE;
1505 
1506     for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1507     {
1508         p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1509         if (p_mdl->active)
1510         {
1511             found=TRUE;
1512             time_latest = p_mdl->time;
1513             for (j=(i+1); j< BTA_HL_NUM_MDL_CFGS; j++ )
1514             {
1515                 p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, j);
1516                 if (p_mdl->active)
1517                 {
1518                     time = p_mdl->time;
1519                     if (time > time_latest)
1520                     {
1521                         time_latest = time;
1522                     }
1523                 }
1524             }
1525             break;
1526         }
1527     }
1528 
1529 
1530     if (found)
1531     {
1532         if (time_latest < BTA_HL_MAX_TIME)
1533         {
1534             *p_cur_time = time_latest+1;
1535         }
1536         else
1537         {
1538             /* need to wrap around */
1539             result = FALSE;
1540         }
1541     }
1542     else
1543     {
1544         *p_cur_time = BTA_HL_MIN_TIME;
1545     }
1546 
1547 #if BTA_HL_DEBUG == TRUE
1548     if (!result)
1549     {
1550         APPL_TRACE_DEBUG2("bta_hl_get_cur_time result=%s cur_time=%d",
1551                           (result?"OK":"FAIL"), *p_cur_time);
1552     }
1553 #endif
1554 
1555     return result;
1556 }
1557 
1558 /*******************************************************************************
1559 **
1560 ** Function      bta_hl_sort_cfg_time_idx
1561 **
1562 ** Description  This function sort the mdl configuration idx stored in array a
1563 **              based on decending time value
1564 **
1565 ** Returns      BOOLEAN - TRUE found
1566 **                        FALSE not found
1567 **
1568 *******************************************************************************/
bta_hl_sort_cfg_time_idx(UINT8 app_idx,UINT8 * a,UINT8 n)1569 void bta_hl_sort_cfg_time_idx(UINT8 app_idx, UINT8 *a, UINT8 n)
1570 {
1571     tBTA_HL_APP_CB      *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1572     UINT8 temp_time, temp_idx;
1573     INT16 i, j;
1574     for (i = 1; i < n; ++i)
1575     {
1576         temp_idx = a[i];
1577         temp_time = p_acb->mdl_cfg[temp_idx].time;
1578         j = i - 1;
1579         while ((j >= 0) && (temp_time < p_acb->mdl_cfg[a[j]].time))
1580         {
1581             a[j + 1] = a[j];
1582             --j;
1583         }
1584         a[j + 1] = temp_idx;
1585     }
1586 }
1587 
1588 /*******************************************************************************
1589 **
1590 ** Function      bta_hl_compact_mdl_cfg_time
1591 **
1592 ** Description  This function finds the MDL configuration index based on
1593 **              the MDL ID
1594 **
1595 ** Returns      BOOLEAN - TRUE found
1596 **                        FALSE not found
1597 **
1598 *******************************************************************************/
bta_hl_compact_mdl_cfg_time(UINT8 app_idx)1599 void  bta_hl_compact_mdl_cfg_time(UINT8 app_idx)
1600 {
1601     tBTA_HL_APP_CB      *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1602     tBTA_HL_MDL_CFG     *p_mdl;
1603     UINT8 i, time_min, cnt=0;
1604     UINT8   s_arr[BTA_HL_NUM_MDL_CFGS];
1605 
1606 
1607     for (i=0; i< BTA_HL_NUM_MDL_CFGS; i++)
1608     {
1609         p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1610         if (p_mdl->active )
1611         {
1612             s_arr[cnt]= i;
1613             cnt++;
1614         }
1615     }
1616 
1617 
1618 
1619 #if BTA_HL_DEBUG == TRUE
1620     APPL_TRACE_DEBUG1("bta_hl_compact_mdl_cfg_time cnt=%d ",cnt );
1621 #endif
1622 
1623 
1624     if (cnt)
1625     {
1626         bta_hl_sort_cfg_time_idx(app_idx, s_arr, cnt);
1627         time_min = BTA_HL_MIN_TIME;
1628         for (i=0;i<cnt; i++)
1629         {
1630             p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, s_arr[i]);
1631             p_mdl->time = time_min + i;
1632             bta_hl_co_save_mdl(p_acb->app_id, s_arr[i], p_mdl);
1633         }
1634     }
1635 
1636 
1637 }
1638 
1639 
1640 
1641 /*******************************************************************************
1642 **
1643 ** Function      bta_hl_is_mdl_exsit_in_mcl
1644 **
1645 ** Description  This function checks whether the MDL ID
1646 **              has already existed in teh MCL or not
1647 **
1648 ** Returns      BOOLEAN - TRUE exist
1649 **                        FALSE does not exist
1650 **
1651 *******************************************************************************/
bta_hl_is_mdl_exsit_in_mcl(UINT8 app_idx,BD_ADDR bd_addr,tBTA_HL_MDL_ID mdl_id)1652 BOOLEAN  bta_hl_is_mdl_exsit_in_mcl(UINT8 app_idx, BD_ADDR bd_addr,
1653                                     tBTA_HL_MDL_ID mdl_id)
1654 {
1655     tBTA_HL_MDL_CFG     *p_mdl;
1656     BOOLEAN             found = FALSE;
1657     UINT8               i;
1658 
1659     for (i = 0; i< BTA_HL_NUM_MDL_CFGS; i++)
1660     {
1661         p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1662         if (p_mdl->active &&
1663             !memcmp(p_mdl->peer_bd_addr, bd_addr,BD_ADDR_LEN))
1664         {
1665             if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS)
1666             {
1667                 if (p_mdl->mdl_id == mdl_id)
1668                 {
1669                     found = TRUE;
1670                     break;
1671                 }
1672             }
1673             else
1674             {
1675                 found = TRUE;
1676                 break;
1677             }
1678         }
1679     }
1680 
1681     return found;
1682 }
1683 
1684 /*******************************************************************************
1685 **
1686 ** Function      bta_hl_delete_mdl_cfg
1687 **
1688 ** Description  This function delete the specified MDL ID
1689 **
1690 ** Returns      BOOLEAN - TRUE Success
1691 **                        FALSE Failed
1692 **
1693 *******************************************************************************/
bta_hl_delete_mdl_cfg(UINT8 app_idx,BD_ADDR bd_addr,tBTA_HL_MDL_ID mdl_id)1694 BOOLEAN  bta_hl_delete_mdl_cfg(UINT8 app_idx, BD_ADDR bd_addr,
1695                                tBTA_HL_MDL_ID mdl_id)
1696 {
1697     tBTA_HL_MDL_CFG     *p_mdl;
1698     BOOLEAN             success = FALSE;
1699     UINT8               i;
1700     tBTA_HL_APP_CB      *p_acb= BTA_HL_GET_APP_CB_PTR(app_idx);
1701     UINT8               app_id = p_acb->app_id;
1702 
1703     for (i = 0; i< BTA_HL_NUM_MDL_CFGS; i++)
1704     {
1705         p_mdl = BTA_HL_GET_MDL_CFG_PTR(app_idx, i);
1706         if (p_mdl->active &&
1707             !memcmp(p_mdl->peer_bd_addr, bd_addr,BD_ADDR_LEN))
1708         {
1709             if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS)
1710             {
1711                 if (p_mdl->mdl_id == mdl_id)
1712                 {
1713                     bta_hl_co_delete_mdl(app_id, i);
1714                     memset(p_mdl, 0, sizeof(tBTA_HL_MDL_CFG));
1715                     success = TRUE;
1716                     break;
1717                 }
1718             }
1719             else
1720             {
1721                 bta_hl_co_delete_mdl(app_id, i);
1722                 memset(p_mdl, 0, sizeof(tBTA_HL_MDL_CFG));
1723                 success = TRUE;
1724             }
1725         }
1726     }
1727 
1728     return success;
1729 }
1730 
1731 
1732 /*******************************************************************************
1733 **
1734 ** Function      bta_hl_is_mdl_value_valid
1735 **
1736 **
1737 ** Description  This function checks the specified MDL ID is in valid range or not
1738 **
1739 ** Returns      BOOLEAN - TRUE Success
1740 **                        FALSE Failed
1741 **
1742 ** note:   mdl_id range   0x0000 reserved,
1743 **                        0x0001-oxFEFF dynamic range,
1744 **                        0xFF00-0xFFFE reserved,
1745 **                        0xFFFF indicates all MDLs (for delete operation only)
1746 **
1747 *******************************************************************************/
bta_hl_is_mdl_value_valid(tBTA_HL_MDL_ID mdl_id)1748 BOOLEAN  bta_hl_is_mdl_value_valid(tBTA_HL_MDL_ID mdl_id)
1749 {
1750     BOOLEAN             status = TRUE;
1751 
1752     if (mdl_id != BTA_HL_DELETE_ALL_MDL_IDS)
1753     {
1754         if (mdl_id != 0)
1755         {
1756             if (mdl_id > BTA_HL_MAX_MDL_VAL )
1757             {
1758                 status = FALSE;
1759             }
1760         }
1761         else
1762         {
1763             status = FALSE;
1764         }
1765     }
1766 
1767     return status;
1768 }
1769 
1770 /*******************************************************************************
1771 **
1772 ** Function      bta_hl_find_mdep_cfg_idx
1773 **
1774 ** Description  This function finds the MDEP configuration index based
1775 **                on the local MDEP ID
1776 **
1777 ** Returns      BOOLEAN - TRUE found
1778 **                        FALSE not found
1779 **
1780 *******************************************************************************/
bta_hl_find_mdep_cfg_idx(UINT8 app_idx,tBTA_HL_MDEP_ID local_mdep_id,UINT8 * p_mdep_cfg_idx)1781 BOOLEAN bta_hl_find_mdep_cfg_idx(UINT8 app_idx,  tBTA_HL_MDEP_ID local_mdep_id,
1782                                  UINT8 *p_mdep_cfg_idx)
1783 {
1784     tBTA_HL_APP_CB      *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1785     tBTA_HL_SUP_FEATURE     *p_sup_feature= &p_acb->sup_feature;
1786     BOOLEAN found =FALSE;
1787     UINT8 i;
1788 
1789     for (i=0; i< p_sup_feature->num_of_mdeps; i++)
1790     {
1791         if ( p_sup_feature->mdep[i].mdep_id == local_mdep_id)
1792         {
1793             found = TRUE;
1794             *p_mdep_cfg_idx = i;
1795             break;
1796         }
1797     }
1798 
1799 #if BTA_HL_DEBUG == TRUE
1800     if (!found)
1801     {
1802         APPL_TRACE_DEBUG3("bta_hl_find_mdep_cfg_idx found=%d mdep_idx=%d local_mdep_id=%d ",
1803                           found,i, local_mdep_id );
1804     }
1805 #endif
1806     return found;
1807 }
1808 
1809 
1810 /*******************************************************************************
1811 **
1812 ** Function      bta_hl_find_rxtx_apdu_size
1813 **
1814 ** Description  This function finds the maximum APDU rx and tx sizes based on
1815 **              the MDEP configuration data
1816 **
1817 ** Returns      void
1818 **
1819 *******************************************************************************/
bta_hl_find_rxtx_apdu_size(UINT8 app_idx,UINT8 mdep_cfg_idx,UINT16 * p_rx_apu_size,UINT16 * p_tx_apu_size)1820 void bta_hl_find_rxtx_apdu_size(UINT8 app_idx, UINT8 mdep_cfg_idx,
1821                                 UINT16 *p_rx_apu_size,
1822                                 UINT16 *p_tx_apu_size)
1823 {
1824     tBTA_HL_APP_CB      *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1825     tBTA_HL_MDEP_CFG     *p_mdep_cfg;
1826     UINT8 i;
1827     UINT16 max_rx_apdu_size=0, max_tx_apdu_size=0;
1828 
1829     p_mdep_cfg = &p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg;
1830 
1831 
1832     for (i=0; i< p_mdep_cfg->num_of_mdep_data_types ; i++)
1833     {
1834 
1835         if (max_rx_apdu_size < p_mdep_cfg->data_cfg[i].max_rx_apdu_size)
1836         {
1837             max_rx_apdu_size = p_mdep_cfg->data_cfg[i].max_rx_apdu_size;
1838         }
1839 
1840         if (max_tx_apdu_size < p_mdep_cfg->data_cfg[i].max_tx_apdu_size)
1841         {
1842             max_tx_apdu_size = p_mdep_cfg->data_cfg[i].max_tx_apdu_size;
1843         }
1844     }
1845 
1846 
1847     *p_rx_apu_size = max_rx_apdu_size;
1848     *p_tx_apu_size = max_tx_apdu_size;
1849 
1850 #if BTA_HL_DEBUG == TRUE
1851     APPL_TRACE_DEBUG2("bta_hl_find_rxtx_apdu_size max_rx_apdu_size=%d max_tx_apdu_size=%d ",
1852                       max_rx_apdu_size, max_tx_apdu_size );
1853 #endif
1854 
1855 
1856 }
1857 
1858 /*******************************************************************************
1859 **
1860 ** Function      bta_hl_validate_peer_cfg
1861 **
1862 ** Description  This function validates the peer DCH configuration
1863 **
1864 ** Returns      BOOLEAN - TRUE validation is successful
1865 **                        FALSE validation failed
1866 **
1867 *******************************************************************************/
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)1868 BOOLEAN bta_hl_validate_peer_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,
1869                                  tBTA_HL_MDEP_ID peer_mdep_id,
1870                                  tBTA_HL_MDEP_ROLE peer_mdep_role,
1871                                  UINT8 sdp_idx)
1872 {
1873     tBTA_HL_MCL_CB      *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1874     tBTA_HL_MDL_CB      *p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1875     tBTA_HL_SDP_REC     *p_rec;
1876     BOOLEAN peer_found =FALSE;
1877     UINT8 i;
1878 
1879     APPL_TRACE_DEBUG1("bta_hl_validate_peer_cfg sdp_idx=%d", sdp_idx);
1880 
1881 
1882     if (p_dcb->local_mdep_id == BTA_HL_ECHO_TEST_MDEP_ID)
1883     {
1884         return TRUE;
1885     }
1886 
1887     p_rec = &p_mcb->sdp.sdp_rec[sdp_idx];
1888     for (i=0; i< p_rec->num_mdeps; i++)
1889     {
1890         if ( (p_rec->mdep_cfg[i].mdep_id == peer_mdep_id) &&
1891              (p_rec->mdep_cfg[i].mdep_role == peer_mdep_role))
1892         {
1893             peer_found = TRUE;
1894 
1895             break;
1896         }
1897     }
1898 
1899 
1900 #if BTA_HL_DEBUG == TRUE
1901     if (!peer_found)
1902     {
1903         APPL_TRACE_DEBUG1("bta_hl_validate_peer_cfg failed num_mdeps=%d",p_rec->num_mdeps);
1904     }
1905 #endif
1906     return peer_found;
1907 }
1908 
1909 
1910 /*******************************************************************************
1911 **
1912 ** Function      bta_hl_chk_local_cfg
1913 **
1914 ** Description  This function check whether the local DCH configuration is OK or not
1915 **
1916 ** Returns      tBTA_HL_STATUS - OK - local DCH configuration is OK
1917 **                               NO_FIRST_RELIABLE - the streaming DCH configuration
1918 **                                                   is not OK and it needs to use
1919 **                                                   reliable DCH configuration
1920 **
1921 *******************************************************************************/
bta_hl_chk_local_cfg(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdep_cfg_idx,tBTA_HL_DCH_CFG local_cfg)1922 tBTA_HL_STATUS bta_hl_chk_local_cfg(UINT8 app_idx, UINT8 mcl_idx,
1923                                     UINT8 mdep_cfg_idx,
1924                                     tBTA_HL_DCH_CFG local_cfg)
1925 {
1926     tBTA_HL_APP_CB      *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1927     tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
1928 
1929     if ( mdep_cfg_idx &&
1930          (p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SOURCE) &&
1931          (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx)) &&
1932          (local_cfg != BTA_HL_DCH_CFG_RELIABLE))
1933     {
1934         status =  BTA_HL_STATUS_NO_FIRST_RELIABLE;
1935         APPL_TRACE_ERROR0("BTA_HL_STATUS_INVALID_DCH_CFG");
1936     }
1937 
1938     return status;
1939 }
1940 
1941 
1942 /*******************************************************************************
1943 **
1944 ** Function      bta_hl_validate_reconnect_params
1945 **
1946 ** Description  This function validates the reconnect parameters
1947 **
1948 ** Returns      BOOLEAN - TRUE validation is successful
1949 **                        FALSE validation failed
1950 *******************************************************************************/
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)1951 BOOLEAN bta_hl_validate_reconnect_params(UINT8 app_idx, UINT8 mcl_idx,
1952                                          tBTA_HL_API_DCH_RECONNECT *p_reconnect,
1953                                          UINT8 *p_mdep_cfg_idx, UINT8 *p_mdl_cfg_idx)
1954 {
1955     tBTA_HL_APP_CB      *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1956     tBTA_HL_SUP_FEATURE *p_sup_feature = &p_acb->sup_feature;
1957     UINT8               num_mdeps;
1958     UINT8               mdl_cfg_idx;
1959     BOOLEAN local_mdep_id_found =FALSE;
1960     BOOLEAN mdl_cfg_found =FALSE;
1961     BOOLEAN            status=FALSE;
1962     UINT8 i, in_use_mdl_idx;
1963 
1964 #if BTA_HL_DEBUG == TRUE
1965     APPL_TRACE_DEBUG1("bta_hl_validate_reconnect_params  mdl_id=%d", p_reconnect->mdl_id);
1966 #endif
1967     if (bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, p_reconnect->mdl_id, &mdl_cfg_idx))
1968     {
1969         mdl_cfg_found = TRUE;
1970     }
1971 
1972 #if BTA_HL_DEBUG == TRUE
1973     if (!mdl_cfg_found)
1974     {
1975         APPL_TRACE_DEBUG0("mdl_cfg_found not found");
1976     }
1977 #endif
1978 
1979 
1980     if (mdl_cfg_found)
1981     {
1982         num_mdeps = p_sup_feature->num_of_mdeps;
1983         for (i=0; i< num_mdeps ; i++)
1984         {
1985             if ( p_sup_feature->mdep[i].mdep_id == p_acb->mdl_cfg[mdl_cfg_idx].local_mdep_id)
1986             {
1987                 local_mdep_id_found = TRUE;
1988                 *p_mdep_cfg_idx =i;
1989                 *p_mdl_cfg_idx = mdl_cfg_idx;
1990                 break;
1991             }
1992         }
1993     }
1994 
1995 #if BTA_HL_DEBUG == TRUE
1996     if (!local_mdep_id_found)
1997     {
1998         APPL_TRACE_DEBUG0("local_mdep_id not found");
1999     }
2000 #endif
2001 
2002 
2003     if (local_mdep_id_found)
2004     {
2005         if (!bta_hl_find_mdl_idx(app_idx,mcl_idx, p_reconnect->mdl_id, &in_use_mdl_idx))
2006         {
2007             status= TRUE;
2008         }
2009         else
2010         {
2011             APPL_TRACE_ERROR1("mdl_id=%d is curreltly in use",p_reconnect->mdl_id);
2012         }
2013     }
2014 
2015 #if BTA_HL_DEBUG == TRUE
2016     if (!status)
2017     {
2018         APPL_TRACE_DEBUG3("Reconnect validation failed local_mdep_id found=%d mdl_cfg_idx found=%d in_use_mdl_idx=%d ",
2019                           local_mdep_id_found,  mdl_cfg_found, in_use_mdl_idx);
2020     }
2021 #endif
2022     return status;
2023 }
2024 
2025 /*******************************************************************************
2026 **
2027 ** Function      bta_hl_find_avail_mcl_idx
2028 **
2029 ** Returns      BOOLEAN - TRUE found
2030 **                        FALSE not found
2031 **
2032 *******************************************************************************/
bta_hl_find_avail_mcl_idx(UINT8 app_idx,UINT8 * p_mcl_idx)2033 BOOLEAN bta_hl_find_avail_mcl_idx(UINT8 app_idx, UINT8 *p_mcl_idx)
2034 {
2035     BOOLEAN found=FALSE;
2036     UINT8 i;
2037 
2038     for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
2039     {
2040         if (!bta_hl_cb.acb[app_idx].mcb[i].in_use)
2041         {
2042             found = TRUE;
2043             *p_mcl_idx = i;
2044             break;
2045         }
2046     }
2047 
2048 #if BTA_HL_DEBUG == TRUE
2049     if (!found)
2050     {
2051         APPL_TRACE_DEBUG2("bta_hl_find_avail_mcl_idx found=%d idx=%d",
2052                           found, i);
2053     }
2054 #endif
2055     return found;
2056 }
2057 
2058 
2059 
2060 /*******************************************************************************
2061 **
2062 ** Function      bta_hl_find_avail_mdl_idx
2063 **
2064 ** Description  This function finds an available MDL control block index
2065 **
2066 ** Returns      BOOLEAN - TRUE found
2067 **                        FALSE not found
2068 **
2069 *******************************************************************************/
bta_hl_find_avail_mdl_idx(UINT8 app_idx,UINT8 mcl_idx,UINT8 * p_mdl_idx)2070 BOOLEAN bta_hl_find_avail_mdl_idx(UINT8 app_idx, UINT8 mcl_idx,
2071                                   UINT8 *p_mdl_idx)
2072 {
2073     tBTA_HL_MCL_CB      *p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2074     BOOLEAN found=FALSE;
2075     UINT8 i;
2076 
2077     for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++)
2078     {
2079         if (!p_mcb->mdl[i].in_use)
2080         {
2081             memset((void *)&p_mcb->mdl[i],0, sizeof(tBTA_HL_MDL_CB));
2082             found = TRUE;
2083             *p_mdl_idx = i;
2084             break;
2085         }
2086     }
2087 
2088 #if BTA_HL_DEBUG == TRUE
2089     if (!found)
2090     {
2091         APPL_TRACE_DEBUG2("bta_hl_find_avail_mdl_idx found=%d idx=%d",
2092                           found, i);
2093     }
2094 #endif
2095     return found;
2096 }
2097 
2098 /*******************************************************************************
2099 **
2100 ** Function      bta_hl_is_a_duplicate_id
2101 **
2102 ** Description  This function finds the application has been used or not
2103 **
2104 ** Returns      BOOLEAN - TRUE the app_id is a duplicate ID
2105 **                        FALSE not a duplicate ID
2106 *******************************************************************************/
bta_hl_is_a_duplicate_id(UINT8 app_id)2107 BOOLEAN bta_hl_is_a_duplicate_id(UINT8 app_id)
2108 {
2109     BOOLEAN is_duplicate=FALSE;
2110     UINT8 i;
2111 
2112     for (i=0; i < BTA_HL_NUM_APPS ; i ++)
2113     {
2114         if (bta_hl_cb.acb[i].in_use &&
2115             (bta_hl_cb.acb[i].app_id == app_id))
2116         {
2117             is_duplicate = TRUE;
2118 
2119             break;
2120         }
2121     }
2122 
2123 #if BTA_HL_DEBUG == TRUE
2124     if (is_duplicate)
2125     {
2126 
2127         APPL_TRACE_DEBUG2("bta_hl_is_a_duplicate_id app_id=%d is_duplicate=%d",
2128                           app_id, is_duplicate);
2129     }
2130 #endif
2131 
2132     return is_duplicate;
2133 }
2134 
2135 
2136 /*******************************************************************************
2137 **
2138 ** Function      bta_hl_find_avail_app_idx
2139 **
2140 ** Description  This function finds an available application control block index
2141 **
2142 ** Returns      BOOLEAN - TRUE found
2143 **                        FALSE not found
2144 **
2145 *******************************************************************************/
bta_hl_find_avail_app_idx(UINT8 * p_idx)2146 BOOLEAN bta_hl_find_avail_app_idx(UINT8 *p_idx)
2147 {
2148     BOOLEAN found=FALSE;
2149     UINT8 i;
2150 
2151     for (i=0; i < BTA_HL_NUM_APPS ; i ++)
2152     {
2153         if (!bta_hl_cb.acb[i].in_use)
2154         {
2155             found = TRUE;
2156             *p_idx = i;
2157             break;
2158         }
2159     }
2160 
2161 #if BTA_HL_DEBUG == TRUE
2162     if (!found)
2163     {
2164         APPL_TRACE_DEBUG2("bta_hl_find_avail_app_idx found=%d app_idx=%d",
2165                           found, i);
2166     }
2167 #endif
2168     return found;
2169 }
2170 
2171 /*******************************************************************************
2172 **
2173 ** Function      bta_hl_app_registration
2174 **
2175 ** Description  This function registers an HDP application MCAP and DP
2176 **
2177 ** Returns      tBTA_HL_STATUS -registration status
2178 **
2179 *******************************************************************************/
bta_hl_app_registration(UINT8 app_idx)2180 tBTA_HL_STATUS bta_hl_app_registration(UINT8 app_idx)
2181 {
2182     tBTA_HL_STATUS  status = BTA_HL_STATUS_OK;
2183     tBTA_HL_APP_CB  *p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2184     tMCA_REG        reg;
2185     tMCA_CS         mca_cs;
2186     UINT8           i, num_of_mdeps;
2187 
2188 
2189 #if BTA_HL_DEBUG == TRUE
2190     APPL_TRACE_DEBUG1("bta_hl_app_registration app_idx=%d", app_idx);
2191 #endif
2192 
2193     reg.ctrl_psm = p_acb->ctrl_psm;
2194     reg.data_psm = p_acb->data_psm;
2195     reg.sec_mask = p_acb->sec_mask;
2196     reg.rsp_tout = BTA_HL_MCAP_RSP_TOUT;
2197 
2198     if ( (p_acb->app_handle = (tBTA_HL_APP_HANDLE) MCA_Register(&reg, bta_hl_mcap_ctrl_cback))!=0)
2199     {
2200         mca_cs.type = MCA_TDEP_ECHO;
2201         mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
2202         mca_cs.p_data_cback = bta_hl_mcap_data_cback;
2203 
2204         if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
2205                           &(p_acb->sup_feature.mdep[0].mdep_id),
2206                           &mca_cs) == MCA_SUCCESS)
2207         {
2208             if (p_acb->sup_feature.mdep[0].mdep_id != BTA_HL_ECHO_TEST_MDEP_ID)
2209             {
2210                 status = BTA_HL_STATUS_MCAP_REG_FAIL;
2211                 APPL_TRACE_ERROR1("BAD MDEP ID for echo test mdep_id=%d",
2212                                   p_acb->sup_feature.mdep[0].mdep_id );
2213             }
2214         }
2215         else
2216         {
2217             status = BTA_HL_STATUS_MCAP_REG_FAIL;
2218             APPL_TRACE_ERROR0("MCA_CreateDep for echo test(mdep_id=0) failed");
2219         }
2220 
2221 
2222         if ((status == BTA_HL_STATUS_OK) &&
2223             bta_hl_co_get_num_of_mdep(p_acb->app_id, &num_of_mdeps))
2224         {
2225             p_acb->sup_feature.num_of_mdeps = num_of_mdeps+1;
2226 
2227             for (i=1; i<p_acb->sup_feature.num_of_mdeps; i++)
2228             {
2229                 mca_cs.type = MCA_TDEP_DATA;
2230                 mca_cs.max_mdl = BTA_HL_NUM_MDLS_PER_MDEP;
2231                 mca_cs.p_data_cback = bta_hl_mcap_data_cback;
2232 
2233                 if (MCA_CreateDep((tMCA_HANDLE)p_acb->app_handle,
2234                                   &(p_acb->sup_feature.mdep[i].mdep_id), &mca_cs) == MCA_SUCCESS)
2235                 {
2236                     if (bta_hl_co_get_mdep_config(p_acb->app_id,
2237                                                   i,
2238                                                   p_acb->sup_feature.mdep[i].mdep_id,
2239                                                   &p_acb->sup_feature.mdep[i].mdep_cfg))
2240                     {
2241                         if (p_acb->sup_feature.mdep[i].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
2242                         {
2243                             p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SOURCE;
2244                         }
2245                         else if (p_acb->sup_feature.mdep[i].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SINK)
2246                         {
2247                             p_acb->sup_feature.app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SINK;
2248                         }
2249                         else
2250                         {
2251                             status = BTA_HL_STATUS_MDEP_CO_FAIL;
2252                             break;
2253                         }
2254                     }
2255                     else
2256                     {
2257                         status = BTA_HL_STATUS_MDEP_CO_FAIL;
2258                         break;
2259                     }
2260                 }
2261                 else
2262                 {
2263                     status = BTA_HL_STATUS_MCAP_REG_FAIL;
2264                     break;
2265                 }
2266             }
2267 
2268 
2269 
2270             if ((status == BTA_HL_STATUS_OK) &&
2271                 (p_acb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SOURCE))
2272             {
2273                 /* this is a source only applciation */
2274                 p_acb->sup_feature.advertize_source_sdp =
2275                 bta_hl_co_advrtise_source_sdp(p_acb->app_id);
2276             }
2277 
2278             if ((status == BTA_HL_STATUS_OK)&&
2279                 (!bta_hl_co_get_echo_config(p_acb->app_id, &p_acb->sup_feature.echo_cfg)))
2280             {
2281                 status = BTA_HL_STATUS_ECHO_CO_FAIL;
2282             }
2283 
2284             if ((status == BTA_HL_STATUS_OK)&&
2285                 (!bta_hl_co_load_mdl_config(p_acb->app_id, BTA_HL_NUM_MDL_CFGS, &p_acb->mdl_cfg[0])))
2286             {
2287                 status = BTA_HL_STATUS_MDL_CFG_CO_FAIL;
2288             }
2289         }
2290         else
2291         {
2292             status = BTA_HL_STATUS_MDEP_CO_FAIL;
2293         }
2294     }
2295     else
2296     {
2297         status = BTA_HL_STATUS_MCAP_REG_FAIL;
2298     }
2299 
2300     if (status == BTA_HL_STATUS_OK)
2301     {
2302         status = bta_hl_sdp_register(app_idx);
2303     }
2304 
2305     return status;
2306 }
2307 
2308 
2309 /*******************************************************************************
2310 **
2311 ** Function         bta_hl_discard_data
2312 **
2313 ** Description  This function discard an HDP event
2314 **
2315 ** Returns     void
2316 **
2317 *******************************************************************************/
bta_hl_discard_data(UINT16 event,tBTA_HL_DATA * p_data)2318 void bta_hl_discard_data(UINT16 event, tBTA_HL_DATA *p_data)
2319 {
2320 
2321 #if BTA_HL_DEBUG == TRUE
2322     APPL_TRACE_ERROR1("BTA HL Discard event=%s",bta_hl_evt_code(event));
2323 
2324 #endif
2325 
2326     switch (event)
2327     {
2328         case BTA_HL_API_SEND_DATA_EVT:
2329             break;
2330 
2331         case BTA_HL_MCA_RCV_DATA_EVT:
2332             utl_freebuf((void**)&p_data->mca_rcv_data_evt.p_pkt);
2333             break;
2334 
2335         default:
2336             /*Nothing to free*/
2337             break;
2338     }
2339 }
2340 
2341 /*******************************************************************************
2342 **
2343 ** Function         bta_hl_save_mdl_cfg
2344 **
2345 ** Description    This function saves the MDL configuration
2346 **
2347 ** Returns     void
2348 **
2349 *******************************************************************************/
bta_hl_save_mdl_cfg(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdl_idx)2350 void bta_hl_save_mdl_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx )
2351 {
2352     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
2353     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2354     tBTA_HL_MDL_CB      *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2355     UINT8 mdl_cfg_idx;
2356     tBTA_HL_MDL_ID mdl_id;
2357     BOOLEAN      found=TRUE;
2358     tBTA_HL_MDL_CFG mdl_cfg;
2359     tBTA_HL_MDEP *p_mdep_cfg;
2360     tBTA_HL_L2CAP_CFG_INFO l2cap_cfg;
2361     UINT8 time_val;
2362     mdl_id = p_dcb->mdl_id;
2363     if (!bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, mdl_id, &mdl_cfg_idx))
2364     {
2365         if (!bta_hl_find_avail_mdl_cfg_idx(app_idx, mcl_idx, &mdl_cfg_idx))
2366         {
2367             APPL_TRACE_ERROR0("No space to save the MDL config");
2368             found= FALSE; /*no space available*/
2369         }
2370     }
2371 
2372     if (found)
2373     {
2374         bta_hl_get_l2cap_cfg(p_dcb->mdl_handle, &l2cap_cfg);
2375         if (!bta_hl_get_cur_time(app_idx, &time_val ))
2376         {
2377             bta_hl_compact_mdl_cfg_time(app_idx);
2378             bta_hl_get_cur_time(app_idx, &time_val);
2379         }
2380         mdl_cfg.active = TRUE;
2381         mdl_cfg.time = time_val;
2382         mdl_cfg.mdl_id  = p_dcb->mdl_id;
2383         mdl_cfg.dch_mode = p_dcb->dch_mode;
2384         mdl_cfg.mtu = l2cap_cfg.mtu;
2385         mdl_cfg.fcs = l2cap_cfg.fcs;
2386 
2387         bdcpy(mdl_cfg.peer_bd_addr, p_mcb->bd_addr);
2388         mdl_cfg.local_mdep_id= p_dcb->local_mdep_id;
2389         p_mdep_cfg = &p_acb->sup_feature.mdep[p_dcb->local_mdep_cfg_idx];
2390         mdl_cfg.local_mdep_role= p_mdep_cfg->mdep_cfg.mdep_role;
2391         memcpy(&p_acb->mdl_cfg[mdl_cfg_idx], &mdl_cfg, sizeof(tBTA_HL_MDL_CFG));
2392         bta_hl_co_save_mdl(p_acb->app_id, mdl_cfg_idx, &mdl_cfg);
2393     }
2394 
2395 #if BTA_HL_DEBUG == TRUE
2396     if (found)
2397     {
2398         if (p_dcb->mtu != l2cap_cfg.mtu)
2399         {
2400             APPL_TRACE_WARNING2("MCAP and L2CAP peer mtu size out of sync from MCAP mtu=%d from l2cap mtu=%d",
2401                                 p_dcb->mtu, l2cap_cfg.mtu);
2402         }
2403         APPL_TRACE_DEBUG1("bta_hl_save_mdl_cfg saved=%d", found);
2404         APPL_TRACE_DEBUG4("Saved. L2cap cfg mdl_id=%d mtu=%d fcs=%d dch_mode=%d",
2405                           mdl_cfg.mdl_id, mdl_cfg.mtu, mdl_cfg.fcs,  mdl_cfg.dch_mode);
2406     }
2407 #endif
2408 
2409 
2410 
2411 }
2412 
2413 /*******************************************************************************
2414 **
2415 ** Function      bta_hl_set_dch_chan_cfg
2416 **
2417 ** Description    This function setups the L2CAP DCH channel configuration
2418 **
2419 ** Returns     void
2420 *******************************************************************************/
bta_hl_set_dch_chan_cfg(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdl_idx,tBTA_HL_DATA * p_data)2421 void bta_hl_set_dch_chan_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx,tBTA_HL_DATA *p_data)
2422 {
2423     tBTA_HL_APP_CB *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
2424     tBTA_HL_MDL_CB *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2425     UINT8 l2cap_mode = L2CAP_FCR_ERTM_MODE;
2426     tBTA_HL_SUP_FEATURE *p_sup_feature= &p_acb->sup_feature;
2427     UINT8 local_mdep_cfg_idx = p_dcb->local_mdep_cfg_idx;
2428 
2429     switch (p_dcb->dch_oper)
2430     {
2431         case BTA_HL_DCH_OP_LOCAL_RECONNECT:
2432         case BTA_HL_DCH_OP_REMOTE_RECONNECT:
2433             if (p_dcb->dch_mode  == BTA_HL_DCH_MODE_STREAMING)
2434                 l2cap_mode = L2CAP_FCR_STREAM_MODE;
2435             break;
2436         case BTA_HL_DCH_OP_LOCAL_OPEN:
2437             if (p_data->mca_evt.mca_data.create_cfm.cfg == BTA_HL_DCH_CFG_STREAMING)
2438                 l2cap_mode = L2CAP_FCR_STREAM_MODE;
2439             break;
2440         case BTA_HL_DCH_OP_REMOTE_OPEN:
2441             if (p_dcb->local_cfg == BTA_HL_DCH_CFG_STREAMING )
2442                 l2cap_mode = L2CAP_FCR_STREAM_MODE;
2443             break;
2444         default:
2445             APPL_TRACE_ERROR1("Invalid dch oper=%d for set dch chan cfg", p_dcb->dch_oper);
2446             break;
2447     }
2448     p_dcb->chnl_cfg.fcr_opt.mode        = l2cap_mode;
2449     p_dcb->chnl_cfg.fcr_opt.mps         = bta_hl_set_mps(p_dcb->max_rx_apdu_size);
2450     p_dcb->chnl_cfg.fcr_opt.tx_win_sz   = bta_hl_set_tx_win_size(p_dcb->max_rx_apdu_size,
2451                                                                  p_dcb->chnl_cfg.fcr_opt.mps);
2452     p_dcb->chnl_cfg.fcr_opt.max_transmit= BTA_HL_L2C_MAX_TRANSMIT;
2453     p_dcb->chnl_cfg.fcr_opt.rtrans_tout = BTA_HL_L2C_RTRANS_TOUT;
2454     p_dcb->chnl_cfg.fcr_opt.mon_tout    = BTA_HL_L2C_MON_TOUT;
2455 
2456     p_dcb->chnl_cfg.user_rx_pool_id     = bta_hl_set_user_rx_pool_id(p_dcb->max_rx_apdu_size);
2457     p_dcb->chnl_cfg.user_tx_pool_id     = bta_hl_set_user_tx_pool_id(p_dcb->max_tx_apdu_size);
2458     p_dcb->chnl_cfg.fcr_rx_pool_id      = BTA_HL_L2C_FCR_RX_POOL_ID;
2459     p_dcb->chnl_cfg.fcr_tx_pool_id      = BTA_HL_L2C_FCR_TX_POOL_ID;
2460     p_dcb->chnl_cfg.data_mtu            = p_dcb->max_rx_apdu_size;
2461 
2462     p_dcb->chnl_cfg.fcs = BTA_HL_MCA_NO_FCS;
2463     if (local_mdep_cfg_idx !=  BTA_HL_ECHO_TEST_MDEP_CFG_IDX)
2464     {
2465         if (p_sup_feature->mdep[local_mdep_cfg_idx].mdep_cfg.mdep_role ==
2466             BTA_HL_MDEP_ROLE_SOURCE)
2467         {
2468             p_dcb->chnl_cfg.fcs = BTA_HL_DEFAULT_SOURCE_FCS;
2469         }
2470     }
2471     else
2472     {
2473         p_dcb->chnl_cfg.fcs = BTA_HL_MCA_USE_FCS;
2474     }
2475 
2476 #if BTA_HL_DEBUG == TRUE
2477     APPL_TRACE_DEBUG1("L2CAP Params l2cap_mode[3-ERTM 4-STREAM]=%d", l2cap_mode);
2478     APPL_TRACE_DEBUG2("Use FCS =%s mtu=%d", ((p_dcb->chnl_cfg.fcs & 1)?"YES":"NO"),
2479                       p_dcb->chnl_cfg.data_mtu);
2480     APPL_TRACE_DEBUG5("tx_win_sz=%d, max_transmit=%d, rtrans_tout=%d, mon_tout=%d, mps=%d",
2481                       p_dcb->chnl_cfg.fcr_opt.tx_win_sz,
2482                       p_dcb->chnl_cfg.fcr_opt.max_transmit,
2483                       p_dcb->chnl_cfg.fcr_opt.rtrans_tout,
2484                       p_dcb->chnl_cfg.fcr_opt.mon_tout,
2485                       p_dcb->chnl_cfg.fcr_opt.mps);
2486 
2487     APPL_TRACE_DEBUG4("USER rx_pool_id=%d, tx_pool_id=%d, FCR rx_pool_id=%d, tx_pool_id=%d",
2488                       p_dcb->chnl_cfg.user_rx_pool_id,
2489                       p_dcb->chnl_cfg.user_tx_pool_id,
2490                       p_dcb->chnl_cfg.fcr_rx_pool_id,
2491                       p_dcb->chnl_cfg.fcr_tx_pool_id);
2492 
2493 #endif
2494 
2495 
2496 
2497 
2498 
2499 
2500 
2501 
2502 }
2503 
2504 /*******************************************************************************
2505 **
2506 ** Function      bta_hl_get_l2cap_cfg
2507 **
2508 ** Description    This function get the current L2CAP channel configuration
2509 **
2510 ** Returns     BOOLEAN - TRUE - operation is successful
2511 *******************************************************************************/
bta_hl_get_l2cap_cfg(tBTA_HL_MDL_HANDLE mdl_hnd,tBTA_HL_L2CAP_CFG_INFO * p_cfg)2512 BOOLEAN bta_hl_get_l2cap_cfg(tBTA_HL_MDL_HANDLE mdl_hnd, tBTA_HL_L2CAP_CFG_INFO *p_cfg)
2513 {
2514     BOOLEAN success = FALSE;
2515     UINT16 lcid;
2516     tL2CAP_CFG_INFO *p_our_cfg;
2517     tL2CAP_CH_CFG_BITS our_cfg_bits;
2518     tL2CAP_CFG_INFO *p_peer_cfg;
2519     tL2CAP_CH_CFG_BITS peer_cfg_bits;
2520 
2521     lcid = MCA_GetL2CapChannel((tMCA_DL) mdl_hnd);
2522     if ( lcid &&
2523          L2CA_GetCurrentConfig(lcid, &p_our_cfg, &our_cfg_bits, &p_peer_cfg,
2524                                &peer_cfg_bits))
2525     {
2526         p_cfg->fcs = BTA_HL_MCA_NO_FCS;
2527         if (our_cfg_bits & L2CAP_CH_CFG_MASK_FCS)
2528         {
2529             p_cfg->fcs |= p_our_cfg->fcs;
2530         }
2531         else
2532         {
2533             p_cfg->fcs = BTA_HL_MCA_USE_FCS;
2534         }
2535 
2536         if (p_cfg->fcs != BTA_HL_MCA_USE_FCS )
2537         {
2538             if (peer_cfg_bits & L2CAP_CH_CFG_MASK_FCS)
2539             {
2540                 p_cfg->fcs |= p_peer_cfg->fcs;
2541             }
2542             else
2543             {
2544                 p_cfg->fcs = BTA_HL_MCA_USE_FCS;
2545             }
2546         }
2547 
2548         p_cfg->mtu =0;
2549         if (peer_cfg_bits & L2CAP_CH_CFG_MASK_MTU)
2550         {
2551             p_cfg->mtu = p_peer_cfg->mtu;
2552         }
2553         else
2554         {
2555             p_cfg->mtu = L2CAP_DEFAULT_MTU;
2556         }
2557         success = TRUE;
2558     }
2559 
2560 #if BTA_HL_DEBUG == TRUE
2561     if (!success)
2562     {
2563         APPL_TRACE_DEBUG3("bta_hl_get_l2cap_cfg success=%d mdl=%d lcid=%d", success, mdl_hnd, lcid);
2564         APPL_TRACE_DEBUG2("l2cap mtu=%d fcs=%d", p_cfg->mtu, p_cfg->fcs);
2565     }
2566 #endif
2567 
2568     return success;
2569 }
2570 
2571 /*******************************************************************************
2572 **
2573 ** Function      bta_hl_validate_chan_cfg
2574 **
2575 ** Description    This function validates the L2CAP channel configuration
2576 **
2577 ** Returns     BOOLEAN - TRUE - validation is successful
2578 *******************************************************************************/
bta_hl_validate_chan_cfg(UINT8 app_idx,UINT8 mcl_idx,UINT8 mdl_idx)2579 BOOLEAN bta_hl_validate_chan_cfg(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx)
2580 {
2581     tBTA_HL_APP_CB *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
2582     tBTA_HL_MDL_CB *p_dcb  = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2583     BOOLEAN success = FALSE;
2584     UINT8 mdl_cfg_idx;
2585     tBTA_HL_L2CAP_CFG_INFO l2cap_cfg;
2586 
2587 
2588     if (bta_hl_get_l2cap_cfg(p_dcb->mdl_handle, &l2cap_cfg) &&
2589         bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, p_dcb->mdl_id, &mdl_cfg_idx))
2590     {
2591         if ((p_acb->mdl_cfg[mdl_cfg_idx].mtu <= l2cap_cfg.mtu) &&
2592             (p_acb->mdl_cfg[mdl_cfg_idx].fcs == l2cap_cfg.fcs) &&
2593             (p_acb->mdl_cfg[mdl_cfg_idx].dch_mode == p_dcb->dch_mode))
2594         {
2595             success = TRUE;
2596         }
2597     }
2598 
2599 
2600 #if BTA_HL_DEBUG == TRUE
2601 
2602     if (p_dcb->mtu != l2cap_cfg.mtu)
2603     {
2604         APPL_TRACE_WARNING2("MCAP and L2CAP peer mtu size out of sync from MCAP mtu=%d from l2cap mtu=%d",
2605                             p_dcb->mtu, l2cap_cfg.mtu);
2606     }
2607 
2608     if (!success)
2609     {
2610         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);
2611         APPL_TRACE_DEBUG3("Cur. L2cap cfg mtu=%d fcs=%d dch_mode=%d", l2cap_cfg.mtu, l2cap_cfg.fcs, p_dcb->dch_mode);
2612         APPL_TRACE_DEBUG3("From saved: L2cap cfg mtu=%d fcs=%d dch_mode=%d", p_acb->mdl_cfg[mdl_cfg_idx].mtu,
2613                           p_acb->mdl_cfg[mdl_cfg_idx].fcs , p_acb->mdl_cfg[mdl_cfg_idx].dch_mode);
2614     }
2615 #endif
2616 
2617     return success;
2618 }
2619 
2620 
2621 /*******************************************************************************
2622 **
2623 ** Function      bta_hl_is_cong_on
2624 **
2625 ** Description    This function checks whether the congestion condition is on or not
2626 **
2627 ** Returns      BOOLEAN - TRUE DCH is congested
2628 **                        FALSE not congested
2629 **
2630 *******************************************************************************/
bta_hl_is_cong_on(UINT8 app_id,BD_ADDR bd_addr,tBTA_HL_MDL_ID mdl_id)2631 BOOLEAN  bta_hl_is_cong_on(UINT8 app_id, BD_ADDR bd_addr, tBTA_HL_MDL_ID mdl_id)
2632 
2633 {
2634     tBTA_HL_MDL_CB      *p_dcb;
2635     UINT8   app_idx, mcl_idx, mdl_idx;
2636     BOOLEAN cong_status = TRUE;
2637 
2638     if (bta_hl_find_app_idx(app_id, &app_idx))
2639     {
2640         if (bta_hl_find_mcl_idx(app_idx, bd_addr, &mcl_idx ))
2641         {
2642             if (bta_hl_find_mdl_idx(app_idx, mcl_idx, mdl_id, &mdl_idx ))
2643             {
2644                 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2645                 cong_status  = p_dcb->cong;
2646             }
2647         }
2648     }
2649 
2650     return cong_status;
2651 }
2652 
2653 /*******************************************************************************
2654 **
2655 ** Function      bta_hl_check_cch_close
2656 **
2657 ** Description   This function checks whether there is a pending CCH close request
2658 **               or not
2659 **
2660 ** Returns      void
2661 *******************************************************************************/
bta_hl_check_cch_close(UINT8 app_idx,UINT8 mcl_idx,tBTA_HL_DATA * p_data,BOOLEAN check_dch_setup)2662 void bta_hl_check_cch_close(UINT8 app_idx, UINT8 mcl_idx, tBTA_HL_DATA *p_data, BOOLEAN check_dch_setup )
2663 {
2664     tBTA_HL_MCL_CB      *p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2665     tBTA_HL_MDL_CB      *p_dcb;
2666     UINT8               mdl_idx;
2667 
2668 #if (BTA_HL_DEBUG == TRUE)
2669     APPL_TRACE_DEBUG1("bta_hl_check_cch_close cch_close_dch_oper=%d",p_mcb->cch_close_dch_oper );
2670 #endif
2671 
2672     if (p_mcb->cch_oper == BTA_HL_CCH_OP_LOCAL_CLOSE)
2673     {
2674         if (check_dch_setup && bta_hl_find_dch_setup_mdl_idx(app_idx, mcl_idx, &mdl_idx))
2675         {
2676             p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
2677             if (!p_mcb->rsp_tout)
2678             {
2679                 p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_ABORT;
2680 
2681                 if (!p_dcb->abort_oper)
2682                 {
2683                     p_dcb->abort_oper |= BTA_HL_ABORT_CCH_CLOSE_MASK;
2684                     bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_ABORT_EVT, p_data);
2685                 }
2686             }
2687             else
2688             {
2689                 p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_CLOSE;
2690                 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
2691             }
2692         }
2693         else if (bta_hl_find_an_active_mdl_idx(app_idx, mcl_idx,&mdl_idx))
2694         {
2695             p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_CLOSE;
2696             bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_EVT, p_data);
2697         }
2698         else
2699         {
2700             p_mcb->cch_close_dch_oper = BTA_HL_CCH_CLOSE_OP_DCH_NONE;
2701             bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_CLOSE_EVT, p_data);
2702         }
2703     }
2704 }
2705 
2706 /*******************************************************************************
2707 **
2708 ** Function         bta_hl_clean_app
2709 **
2710 ** Description      Cleans up the HDP application resources and control block
2711 **
2712 ** Returns          void
2713 **
2714 *******************************************************************************/
bta_hl_clean_app(UINT8 app_idx)2715 void bta_hl_clean_app(UINT8 app_idx)
2716 {
2717     tBTA_HL_APP_CB         *p_acb   = BTA_HL_GET_APP_CB_PTR(app_idx);
2718     int i, num_act_apps=0;
2719 
2720 #if BTA_HL_DEBUG == TRUE
2721     APPL_TRACE_DEBUG0("bta_hl_clean_app");
2722 #endif
2723     MCA_Deregister((tMCA_HANDLE)p_acb->app_handle);
2724 
2725     if (p_acb->sdp_handle) SDP_DeleteRecord(p_acb->sdp_handle);
2726 
2727     memset((void *) p_acb, 0, sizeof(tBTA_HL_APP_CB));
2728 
2729     /* check any application is still active */
2730     for (i=0; i < BTA_HL_NUM_APPS ; i ++)
2731     {
2732         p_acb = BTA_HL_GET_APP_CB_PTR(i);
2733         if (p_acb->in_use) num_act_apps++;
2734     }
2735 
2736     if (!num_act_apps)
2737     {
2738         bta_sys_remove_uuid(UUID_SERVCLASS_HDP_PROFILE);
2739     }
2740 }
2741 
2742 /*******************************************************************************
2743 **
2744 ** Function      bta_hl_check_deregistration
2745 **
2746 ** Description   This function checks whether there is a pending deregistration
2747 **               request or not
2748 **
2749 ** Returns      void
2750 *******************************************************************************/
bta_hl_check_deregistration(UINT8 app_idx,tBTA_HL_DATA * p_data)2751 void bta_hl_check_deregistration(UINT8 app_idx, tBTA_HL_DATA *p_data )
2752 {
2753     tBTA_HL_APP_CB      *p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
2754     tBTA_HL_MCL_CB      *p_mcb;
2755     UINT8               mcl_idx;
2756     tBTA_HL             evt_data;
2757 
2758 #if (BTA_HL_DEBUG == TRUE)
2759     APPL_TRACE_DEBUG0("bta_hl_check_deregistration");
2760 #endif
2761 
2762     if (p_acb->deregistering)
2763     {
2764         if (bta_hl_find_an_in_use_mcl_idx(app_idx, &mcl_idx))
2765         {
2766             p_mcb  = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2767             if (p_mcb->cch_oper != BTA_HL_CCH_OP_LOCAL_CLOSE)
2768             {
2769                 p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_CLOSE;
2770                 bta_hl_check_cch_close(app_idx,mcl_idx,p_data, TRUE);
2771             }
2772         }
2773         else
2774         {
2775             /* all cchs are closed */
2776             evt_data.dereg_cfm.app_handle = p_acb->app_handle;
2777             evt_data.dereg_cfm.status = BTA_HL_STATUS_OK;
2778             p_acb->p_cback(BTA_HL_DEREGISTER_CFM_EVT, (tBTA_HL *) &evt_data );
2779             bta_hl_clean_app(app_idx);
2780             bta_hl_check_disable(p_data);
2781         }
2782     }
2783 }
2784 
2785 
2786 /*******************************************************************************
2787 **
2788 ** Function      bta_hl_check_disable
2789 **
2790 ** Description   This function checks whether there is a pending disable
2791 **               request or not
2792 **
2793 ** Returns      void
2794 **
2795 *******************************************************************************/
bta_hl_check_disable(tBTA_HL_DATA * p_data)2796 void bta_hl_check_disable(tBTA_HL_DATA *p_data )
2797 {
2798     tBTA_HL_CB          *p_cb= &bta_hl_cb;
2799     tBTA_HL_APP_CB      *p_acb;
2800     UINT8               app_idx;
2801     tBTA_HL_CTRL        evt_data;
2802 
2803 #if (BTA_HL_DEBUG == TRUE)
2804     APPL_TRACE_DEBUG0("bta_hl_check_disable");
2805 #endif
2806 
2807     if (bta_hl_cb.disabling)
2808     {
2809         if (bta_hl_find_an_in_use_app_idx(&app_idx))
2810         {
2811             p_acb  = BTA_HL_GET_APP_CB_PTR(app_idx);
2812             if (!p_acb->deregistering)
2813             {
2814                 p_acb->deregistering = TRUE;
2815                 bta_hl_check_deregistration(app_idx, p_data);
2816             }
2817         }
2818         else
2819         {
2820             /* all apps are deregistered */
2821             bta_sys_deregister(BTA_ID_HL);
2822             evt_data.disable_cfm.status = BTA_HL_STATUS_OK;
2823             if (p_cb->p_ctrl_cback) p_cb->p_ctrl_cback(BTA_HL_CTRL_DISABLE_CFM_EVT, (tBTA_HL_CTRL *) &evt_data);
2824             memset((void *) p_cb, 0, sizeof(tBTA_HL_CB));
2825         }
2826     }
2827 }
2828 
2829 /*******************************************************************************
2830 **
2831 ** Function      bta_hl_build_abort_cfm
2832 **
2833 ** Description   This function builds the abort confirmation event data
2834 **
2835 ** Returns      None
2836 **
2837 *******************************************************************************/
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)2838 void  bta_hl_build_abort_cfm(tBTA_HL *p_evt_data,
2839                              tBTA_HL_APP_HANDLE app_handle,
2840                              tBTA_HL_MCL_HANDLE mcl_handle,
2841                              tBTA_HL_STATUS status)
2842 {
2843     p_evt_data->dch_abort_cfm.status = status;
2844     p_evt_data->dch_abort_cfm.mcl_handle = mcl_handle;
2845     p_evt_data->dch_abort_cfm.app_handle = app_handle;
2846 }
2847 
2848 /*******************************************************************************
2849 **
2850 ** Function      bta_hl_build_abort_ind
2851 **
2852 ** Description   This function builds the abort indication event data
2853 **
2854 ** Returns      None
2855 **
2856 *******************************************************************************/
bta_hl_build_abort_ind(tBTA_HL * p_evt_data,tBTA_HL_APP_HANDLE app_handle,tBTA_HL_MCL_HANDLE mcl_handle)2857 void  bta_hl_build_abort_ind(tBTA_HL *p_evt_data,
2858                              tBTA_HL_APP_HANDLE app_handle,
2859                              tBTA_HL_MCL_HANDLE mcl_handle)
2860 {
2861     p_evt_data->dch_abort_ind.mcl_handle = mcl_handle;
2862     p_evt_data->dch_abort_ind.app_handle = app_handle;
2863 }
2864 /*******************************************************************************
2865 **
2866 ** Function      bta_hl_build_close_cfm
2867 **
2868 ** Description   This function builds the close confirmation event data
2869 **
2870 ** Returns      None
2871 **
2872 *******************************************************************************/
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)2873 void  bta_hl_build_dch_close_cfm(tBTA_HL *p_evt_data,
2874                                  tBTA_HL_APP_HANDLE app_handle,
2875                                  tBTA_HL_MCL_HANDLE mcl_handle,
2876                                  tBTA_HL_MDL_HANDLE mdl_handle,
2877                                  tBTA_HL_STATUS status)
2878 {
2879     p_evt_data->dch_close_cfm.status = status;
2880     p_evt_data->dch_close_cfm.mdl_handle = mdl_handle;
2881     p_evt_data->dch_close_cfm.mcl_handle = mcl_handle;
2882     p_evt_data->dch_close_cfm.app_handle = app_handle;
2883 }
2884 
2885 /*******************************************************************************
2886 **
2887 ** Function      bta_hl_build_dch_close_ind
2888 **
2889 ** Description   This function builds the close indication event data
2890 **
2891 ** Returns      None
2892 **
2893 *******************************************************************************/
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)2894 void  bta_hl_build_dch_close_ind(tBTA_HL *p_evt_data,
2895                                  tBTA_HL_APP_HANDLE app_handle,
2896                                  tBTA_HL_MCL_HANDLE mcl_handle,
2897                                  tBTA_HL_MDL_HANDLE mdl_handle,
2898                                  BOOLEAN intentional)
2899 {
2900     p_evt_data->dch_close_ind.mdl_handle = mdl_handle;
2901     p_evt_data->dch_close_ind.mcl_handle = mcl_handle;
2902     p_evt_data->dch_close_ind.app_handle = app_handle;
2903     p_evt_data->dch_close_ind.intentional = intentional;
2904 }
2905 
2906 /*******************************************************************************
2907 **
2908 ** Function      bta_hl_build_send_data_cfm
2909 **
2910 ** Description   This function builds the send data confirmation event data
2911 **
2912 ** Returns      None
2913 **
2914 *******************************************************************************/
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)2915 void  bta_hl_build_send_data_cfm(tBTA_HL *p_evt_data,
2916                                  tBTA_HL_APP_HANDLE app_handle,
2917                                  tBTA_HL_MCL_HANDLE mcl_handle,
2918                                  tBTA_HL_MDL_HANDLE mdl_handle,
2919                                  tBTA_HL_STATUS status )
2920 {
2921 
2922     p_evt_data->dch_send_data_cfm.mdl_handle = mdl_handle;
2923     p_evt_data->dch_send_data_cfm.mcl_handle = mcl_handle;
2924     p_evt_data->dch_send_data_cfm.app_handle = app_handle;
2925     p_evt_data->dch_send_data_cfm.status = status;
2926 }
2927 
2928 /*******************************************************************************
2929 **
2930 ** Function      bta_hl_build_rcv_data_ind
2931 **
2932 ** Description   This function builds the received data indication event data
2933 **
2934 ** Returns      None
2935 **
2936 *******************************************************************************/
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)2937 void  bta_hl_build_rcv_data_ind(tBTA_HL *p_evt_data,
2938                                 tBTA_HL_APP_HANDLE app_handle,
2939                                 tBTA_HL_MCL_HANDLE mcl_handle,
2940                                 tBTA_HL_MDL_HANDLE mdl_handle)
2941 {
2942     p_evt_data->dch_rcv_data_ind.mdl_handle = mdl_handle;
2943     p_evt_data->dch_rcv_data_ind.mcl_handle = mcl_handle;
2944     p_evt_data->dch_rcv_data_ind.app_handle = app_handle;
2945 }
2946 
2947 
2948 /*******************************************************************************
2949 **
2950 ** Function      bta_hl_build_cch_open_cfm
2951 **
2952 ** Description   This function builds the CCH open confirmation event data
2953 **
2954 ** Returns      None
2955 **
2956 *******************************************************************************/
bta_hl_build_cch_open_cfm(tBTA_HL * p_evt_data,tBTA_HL_APP_HANDLE app_handle,tBTA_HL_MCL_HANDLE mcl_handle,BD_ADDR bd_addr,tBTA_HL_STATUS status)2957 void  bta_hl_build_cch_open_cfm(tBTA_HL *p_evt_data,
2958                                 tBTA_HL_APP_HANDLE app_handle,
2959                                 tBTA_HL_MCL_HANDLE mcl_handle,
2960                                 BD_ADDR bd_addr,
2961                                 tBTA_HL_STATUS status )
2962 {
2963 
2964     p_evt_data->cch_open_cfm.app_handle = app_handle;
2965     p_evt_data->cch_open_cfm.mcl_handle = mcl_handle;
2966     bdcpy(p_evt_data->cch_open_cfm.bd_addr, bd_addr);
2967     p_evt_data->cch_open_cfm.status = status;
2968 }
2969 
2970 /*******************************************************************************
2971 **
2972 ** Function      bta_hl_build_cch_open_ind
2973 **
2974 ** Description   This function builds the CCH open indication event data
2975 **
2976 ** Returns      None
2977 **
2978 *******************************************************************************/
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)2979 void  bta_hl_build_cch_open_ind(tBTA_HL *p_evt_data, tBTA_HL_APP_HANDLE app_handle,
2980                                 tBTA_HL_MCL_HANDLE mcl_handle,
2981                                 BD_ADDR bd_addr )
2982 {
2983 
2984     p_evt_data->cch_open_ind.app_handle = app_handle;
2985     p_evt_data->cch_open_ind.mcl_handle = mcl_handle;
2986     bdcpy(p_evt_data->cch_open_ind.bd_addr, bd_addr);
2987 }
2988 
2989 /*******************************************************************************
2990 **
2991 ** Function      bta_hl_build_cch_close_cfm
2992 **
2993 ** Description   This function builds the CCH close confirmation event data
2994 **
2995 ** Returns      None
2996 **
2997 *******************************************************************************/
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)2998 void  bta_hl_build_cch_close_cfm(tBTA_HL *p_evt_data,
2999                                  tBTA_HL_APP_HANDLE app_handle,
3000                                  tBTA_HL_MCL_HANDLE mcl_handle,
3001                                  tBTA_HL_STATUS status )
3002 {
3003     p_evt_data->cch_close_cfm.mcl_handle = mcl_handle;
3004     p_evt_data->cch_close_cfm.app_handle = app_handle;
3005     p_evt_data->cch_close_cfm.status = status;
3006 }
3007 
3008 
3009 /*******************************************************************************
3010 **
3011 ** Function      bta_hl_build_cch_close_ind
3012 **
3013 ** Description   This function builds the CCH colse indication event data
3014 **
3015 ** Returns      None
3016 **
3017 *******************************************************************************/
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)3018 void  bta_hl_build_cch_close_ind(tBTA_HL *p_evt_data,
3019                                  tBTA_HL_APP_HANDLE app_handle,
3020                                  tBTA_HL_MCL_HANDLE mcl_handle,
3021                                  BOOLEAN intentional)
3022 {
3023     p_evt_data->cch_close_ind.mcl_handle = mcl_handle;
3024     p_evt_data->cch_close_ind.app_handle = app_handle;
3025     p_evt_data->cch_close_ind.intentional = intentional;
3026 }
3027 
3028 /*******************************************************************************
3029 **
3030 ** Function      bta_hl_build_dch_open_cfm
3031 **
3032 ** Description   This function builds the DCH open confirmation event data
3033 **
3034 ** Returns      None
3035 **
3036 *******************************************************************************/
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)3037 void  bta_hl_build_dch_open_cfm(tBTA_HL *p_evt_data,
3038                                 tBTA_HL_APP_HANDLE app_handle,
3039                                 tBTA_HL_MCL_HANDLE mcl_handle,
3040                                 tBTA_HL_MDL_HANDLE mdl_handle,
3041                                 tBTA_HL_MDEP_ID local_mdep_id,
3042                                 tBTA_HL_MDL_ID mdl_id,
3043                                 tBTA_HL_DCH_MODE dch_mode,
3044                                 BOOLEAN first_reliable,
3045                                 UINT16 mtu,
3046                                 tBTA_HL_STATUS status)
3047 
3048 {
3049     p_evt_data->dch_open_cfm.mdl_handle = mdl_handle;
3050     p_evt_data->dch_open_cfm.mcl_handle = mcl_handle;
3051     p_evt_data->dch_open_cfm.app_handle = app_handle;
3052     p_evt_data->dch_open_cfm.local_mdep_id = local_mdep_id;
3053     p_evt_data->dch_open_cfm.mdl_id = mdl_id;
3054     p_evt_data->dch_open_cfm.dch_mode = dch_mode;
3055     p_evt_data->dch_open_cfm.first_reliable = first_reliable;
3056     p_evt_data->dch_open_cfm.mtu = mtu;
3057     p_evt_data->dch_open_cfm.status = status;
3058 }
3059 
3060 
3061 /*******************************************************************************
3062 **
3063 ** Function      bta_hl_build_sdp_query_cfm
3064 **
3065 ** Description   This function builds the SDP query indication event data
3066 **
3067 ** Returns      None
3068 **
3069 *******************************************************************************/
bta_hl_build_sdp_query_cfm(tBTA_HL * p_evt_data,tBTA_HL_APP_HANDLE app_handle,BD_ADDR bd_addr,tBTA_HL_SDP * p_sdp,tBTA_HL_STATUS status)3070 void  bta_hl_build_sdp_query_cfm(tBTA_HL *p_evt_data,
3071                                  tBTA_HL_APP_HANDLE app_handle,
3072                                  BD_ADDR bd_addr,
3073                                  tBTA_HL_SDP *p_sdp,
3074                                  tBTA_HL_STATUS status)
3075 
3076 {
3077     p_evt_data->sdp_query_cfm.app_handle = app_handle;
3078     bdcpy(p_evt_data->sdp_query_cfm.bd_addr, bd_addr);
3079     p_evt_data->sdp_query_cfm.p_sdp = p_sdp;
3080     p_evt_data->sdp_query_cfm.status = status;
3081 }
3082 
3083 
3084 /*******************************************************************************
3085 **
3086 ** Function      bta_hl_build_delete_mdl_cfm
3087 **
3088 ** Description   This function builds the delete MDL confirmation event data
3089 **
3090 ** Returns      None
3091 **
3092 *******************************************************************************/
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)3093 void  bta_hl_build_delete_mdl_cfm(tBTA_HL *p_evt_data,
3094                                   tBTA_HL_APP_HANDLE app_handle,
3095                                   tBTA_HL_MCL_HANDLE mcl_handle,
3096                                   tBTA_HL_MDL_ID mdl_id,
3097                                   tBTA_HL_STATUS status)
3098 
3099 {
3100     p_evt_data->delete_mdl_cfm.mcl_handle = mcl_handle;
3101     p_evt_data->delete_mdl_cfm.app_handle = app_handle;
3102     p_evt_data->delete_mdl_cfm.mdl_id = mdl_id;
3103     p_evt_data->delete_mdl_cfm.status = status;
3104 }
3105 
3106 /*******************************************************************************
3107 **
3108 ** Function      bta_hl_build_echo_test_cfm
3109 **
3110 ** Description   This function builds the echo test confirmation event data
3111 **
3112 ** Returns      None
3113 **
3114 *******************************************************************************/
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)3115 void  bta_hl_build_echo_test_cfm(tBTA_HL *p_evt_data,
3116                                  tBTA_HL_APP_HANDLE app_handle,
3117                                  tBTA_HL_MCL_HANDLE mcl_handle,
3118                                  tBTA_HL_STATUS status )
3119 {
3120     p_evt_data->echo_test_cfm.mcl_handle = mcl_handle;
3121     p_evt_data->echo_test_cfm.app_handle = app_handle;
3122     p_evt_data->echo_test_cfm.status = status;
3123 }
3124 
3125 
3126 /*****************************************************************************
3127 **  Debug Functions
3128 *****************************************************************************/
3129 #if (BTA_HL_DEBUG == TRUE)
3130 
3131 /*******************************************************************************
3132 **
3133 ** Function         bta_hl_status_code
3134 **
3135 ** Description      get the status string pointer
3136 **
3137 ** Returns          char * - status string pointer
3138 **
3139 *******************************************************************************/
bta_hl_status_code(tBTA_HL_STATUS status)3140 char *bta_hl_status_code(tBTA_HL_STATUS status)
3141 {
3142     switch (status)
3143     {
3144         case BTA_HL_STATUS_OK:
3145             return "BTA_HL_STATUS_OK";
3146         case BTA_HL_STATUS_FAIL:
3147             return "BTA_HL_STATUS_FAIL";
3148         case BTA_HL_STATUS_ABORTED:
3149             return "BTA_HL_STATUS_ABORTED";
3150         case BTA_HL_STATUS_NO_RESOURCE:
3151             return "BTA_HL_STATUS_NO_RESOURCE";
3152         case BTA_HL_STATUS_LAST_ITEM:
3153             return "BTA_HL_STATUS_LAST_ITEM";
3154         case BTA_HL_STATUS_DUPLICATE_APP_ID:
3155             return "BTA_HL_STATUS_DUPLICATE_APP_ID";
3156         case BTA_HL_STATUS_INVALID_APP_HANDLE:
3157             return "BTA_HL_STATUS_INVALID_APP_HANDLE";
3158         case BTA_HL_STATUS_INVALID_MCL_HANDLE:
3159             return "BTA_HL_STATUS_INVALID_MCL_HANDLE";
3160         case BTA_HL_STATUS_MCAP_REG_FAIL:
3161             return "BTA_HL_STATUS_MCAP_REG_FAIL";
3162         case BTA_HL_STATUS_MDEP_CO_FAIL:
3163             return "BTA_HL_STATUS_MDEP_CO_FAIL";
3164         case BTA_HL_STATUS_ECHO_CO_FAIL:
3165             return "BTA_HL_STATUS_ECHO_CO_FAIL";
3166         case BTA_HL_STATUS_MDL_CFG_CO_FAIL:
3167             return "BTA_HL_STATUS_MDL_CFG_CO_FAIL";
3168         case BTA_HL_STATUS_SDP_NO_RESOURCE:
3169             return "BTA_HL_STATUS_SDP_NO_RESOURCE";
3170         case BTA_HL_STATUS_SDP_FAIL:
3171             return "BTA_HL_STATUS_SDP_FAIL";
3172         case BTA_HL_STATUS_NO_CCH:
3173             return "BTA_HL_STATUS_NO_CCH";
3174         case BTA_HL_STATUS_NO_MCL:
3175             return "BTA_HL_STATUS_NO_MCL";
3176 
3177         case BTA_HL_STATUS_NO_FIRST_RELIABLE:
3178             return "BTA_HL_STATUS_NO_FIRST_RELIABLE";
3179         case BTA_HL_STATUS_INVALID_DCH_CFG:
3180             return "BTA_HL_STATUS_INVALID_DCH_CFG";
3181         case BTA_HL_STATUS_INVALID_BD_ADDR:
3182             return "BTA_HL_STATUS_INVALID_BD_ADDR";
3183         case BTA_HL_STATUS_INVALID_RECONNECT_CFG:
3184             return "BTA_HL_STATUS_INVALID_RECONNECT_CFG";
3185         case BTA_HL_STATUS_ECHO_TEST_BUSY:
3186             return "BTA_HL_STATUS_ECHO_TEST_BUSY";
3187         case BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID:
3188             return "BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID";
3189         case BTA_HL_STATUS_INVALID_MDL_ID:
3190             return "BTA_HL_STATUS_INVALID_MDL_ID";
3191         case BTA_HL_STATUS_NO_MDL_ID_FOUND:
3192             return "BTA_HL_STATUS_NO_MDL_ID_FOUND";
3193         case BTA_HL_STATUS_DCH_BUSY:
3194             return "BTA_HL_STATUS_DCH_BUSY";
3195         default:
3196             return "Unknown status code";
3197     }
3198 }
3199 /*******************************************************************************
3200 **
3201 ** Function         bta_hl_evt_code
3202 **
3203 ** Description      Maps HL event code to the corresponding event string
3204 **
3205 ** Returns          string pointer for the associated event name
3206 **
3207 *******************************************************************************/
bta_hl_evt_code(tBTA_HL_INT_EVT evt_code)3208 char *bta_hl_evt_code(tBTA_HL_INT_EVT evt_code)
3209 {
3210     switch (evt_code)
3211     {
3212         case BTA_HL_CCH_OPEN_EVT:
3213             return "BTA_HL_CCH_OPEN_EVT";
3214         case BTA_HL_CCH_SDP_OK_EVT:
3215             return "BTA_HL_CCH_SDP_OK_EVT";
3216         case BTA_HL_CCH_SDP_FAIL_EVT:
3217             return "BTA_HL_CCH_SDP_FAIL_EVT";
3218         case BTA_HL_MCA_CONNECT_IND_EVT:
3219             return "BTA_HL_MCA_CONNECT_IND_EVT";
3220         case BTA_HL_MCA_DISCONNECT_IND_EVT:
3221             return "BTA_HL_MCA_DISCONNECT_IND_EVT";
3222 
3223         case BTA_HL_CCH_CLOSE_EVT:
3224             return "BTA_HL_CCH_CLOSE_EVT";
3225         case BTA_HL_CCH_CLOSE_CMPL_EVT:
3226             return "BTA_HL_CCH_CLOSE_CMPL_EVT";
3227         case BTA_HL_DCH_OPEN_EVT:
3228             return "BTA_HL_DCH_OPEN_EVT";
3229         case BTA_HL_MCA_CREATE_IND_EVT:
3230             return "BTA_HL_MCA_CREATE_IND_EVT";
3231         case BTA_HL_MCA_CREATE_CFM_EVT:
3232             return "BTA_HL_MCA_CREATE_CFM_EVT";
3233         case BTA_HL_MCA_OPEN_IND_EVT:
3234             return "BTA_HL_MCA_OPEN_IND_EVT";
3235         case BTA_HL_MCA_OPEN_CFM_EVT:
3236             return "BTA_HL_MCA_OPEN_CFM_EVT";
3237         case BTA_HL_DCH_CLOSE_EVT:
3238             return "BTA_HL_DCH_CLOSE_EVT";
3239         case BTA_HL_MCA_CLOSE_IND_EVT:
3240             return "BTA_HL_MCA_CLOSE_IND_EVT";
3241         case BTA_HL_MCA_CLOSE_CFM_EVT:
3242             return "BTA_HL_MCA_CLOSE_CFM_EVT";
3243         case BTA_HL_API_SEND_DATA_EVT:
3244             return "BTA_HL_API_SEND_DATA_EVT";
3245         case BTA_HL_MCA_RCV_DATA_EVT:
3246             return "BTA_HL_MCA_RCV_DATA_EVT";
3247         case BTA_HL_DCH_CLOSE_CMPL_EVT:
3248             return "BTA_HL_DCH_CLOSE_CMPL_EVT";
3249 
3250         case BTA_HL_API_ENABLE_EVT:
3251             return "BTA_HL_API_ENABLE_EVT";
3252         case BTA_HL_API_DISABLE_EVT:
3253             return "BTA_HL_API_DISABLE_EVT";
3254         case BTA_HL_API_REGISTER_EVT:
3255             return "BTA_HL_API_REGISTER_EVT";
3256         case BTA_HL_API_DEREGISTER_EVT:
3257             return "BTA_HL_API_DEREGISTER_EVT";
3258 
3259         case BTA_HL_API_CCH_OPEN_EVT:
3260             return "BTA_HL_API_CCH_OPEN_EVT";
3261 
3262         case BTA_HL_API_CCH_CLOSE_EVT:
3263             return "BTA_HL_API_CCH_CLOSE_EVT";
3264         case BTA_HL_API_DCH_OPEN_EVT:
3265             return "BTA_HL_API_DCH_OPEN_EVT";
3266 
3267         case BTA_HL_API_DCH_RECONNECT_EVT:
3268             return "BTA_HL_API_DCH_RECONNECT_EVT";
3269         case BTA_HL_API_DCH_CLOSE_EVT:
3270             return "BTA_HL_API_DCH_CLOSE_EVT";
3271         case BTA_HL_API_DELETE_MDL_EVT:
3272             return "BTA_HL_API_DELETE_MDL_EVT";
3273         case BTA_HL_API_DCH_ABORT_EVT:
3274             return "BTA_HL_API_DCH_ABORT_EVT";
3275 
3276         case BTA_HL_DCH_RECONNECT_EVT:
3277             return "BTA_HL_DCH_RECONNECT_EVT";
3278         case BTA_HL_DCH_SDP_INIT_EVT:
3279             return "BTA_HL_DCH_SDP_INIT_EVT";
3280         case BTA_HL_DCH_SDP_FAIL_EVT:
3281             return "BTA_HL_DCH_SDP_FAIL_EVT";
3282         case BTA_HL_API_DCH_ECHO_TEST_EVT:
3283             return "BTA_HL_API_DCH_ECHO_TEST_EVT";
3284         case BTA_HL_DCH_CLOSE_ECHO_TEST_EVT:
3285             return "BTA_HL_DCH_CLOSE_ECHO_TEST_EVT";
3286         case BTA_HL_MCA_RECONNECT_IND_EVT:
3287             return "BTA_HL_MCA_RECONNECT_IND_EVT";
3288         case BTA_HL_MCA_RECONNECT_CFM_EVT:
3289             return "BTA_HL_MCA_RECONNECT_CFM_EVT";
3290         case BTA_HL_API_DCH_CREATE_RSP_EVT:
3291             return "BTA_HL_API_DCH_CREATE_RSP_EVT";
3292         case BTA_HL_DCH_ABORT_EVT:
3293             return "BTA_HL_DCH_ABORT_EVT";
3294         case BTA_HL_MCA_ABORT_IND_EVT:
3295             return "BTA_HL_MCA_ABORT_IND_EVT";
3296         case BTA_HL_MCA_ABORT_CFM_EVT:
3297             return "BTA_HL_MCA_ABORT_CFM_EVT";
3298         case BTA_HL_MCA_DELETE_IND_EVT:
3299             return "BTA_HL_MCA_DELETE_IND_EVT";
3300         case BTA_HL_MCA_DELETE_CFM_EVT:
3301             return "BTA_HL_MCA_DELETE_CFM_EVT";
3302         case BTA_HL_MCA_CONG_CHG_EVT:
3303             return "BTA_HL_MCA_CONG_CHG_EVT";
3304         case BTA_HL_CI_GET_TX_DATA_EVT:
3305             return "BTA_HL_CI_GET_TX_DATA_EVT";
3306         case BTA_HL_CI_PUT_RX_DATA_EVT:
3307             return "BTA_HL_CI_PUT_RX_DATA_EVT";
3308         case BTA_HL_CI_GET_ECHO_DATA_EVT:
3309             return "BTA_HL_CI_GET_ECHO_DATA_EVT";
3310         case BTA_HL_DCH_ECHO_TEST_EVT:
3311             return "BTA_HL_DCH_ECHO_TEST_EVT";
3312         case BTA_HL_CI_PUT_ECHO_DATA_EVT:
3313             return "BTA_HL_CI_PUT_ECHO_DATA_EVT";
3314         case BTA_HL_API_SDP_QUERY_EVT:
3315             return "BTA_HL_API_SDP_QUERY_EVT";
3316         case BTA_HL_SDP_QUERY_OK_EVT:
3317             return "BTA_HL_SDP_QUERY_OK_EVT";
3318         case BTA_HL_SDP_QUERY_FAIL_EVT:
3319             return "BTA_HL_SDP_QUERY_FAIL_EVT";
3320         case BTA_HL_MCA_RSP_TOUT_IND_EVT:
3321             return "BTA_HL_MCA_RSP_TOUT_IND_EVT";
3322 
3323         default:
3324             return "Unknown HL event code";
3325     }
3326 }
3327 
3328 #endif  /* Debug Functions */
3329 #endif // HL_INCLUDED
3330 
3331 
3332 
3333 
3334 
3335 
3336 
3337 
3338