1 /******************************************************************************
2 *
3 * Copyright 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 contains the HeaLth device profile (HL) action functions for
22 * the state machine.
23 *
24 ******************************************************************************/
25
26 #include <string.h>
27
28 #include "bt_target.h"
29 #if (HL_INCLUDED == TRUE)
30
31 #include "bt_common.h"
32 #include "bta_hl_api.h"
33 #include "bta_hl_int.h"
34 #include "bta_sys.h"
35 #include "mca_api.h"
36 #include "mca_defs.h"
37 #include "osi/include/osi.h"
38 #include "port_api.h"
39 #include "sdp_api.h"
40 #include "utl.h"
41
42 using bluetooth::Uuid;
43
44 /*****************************************************************************
45 * Local Function prototypes
46 ****************************************************************************/
47 #if (BTA_HL_DEBUG == TRUE)
48 static const char* bta_hl_mcap_evt_code(uint8_t evt_code);
49 static const char* bta_hl_dch_oper_code(tBTA_HL_DCH_OPER oper_code);
50 static const char* bta_hl_cback_evt_code(uint8_t evt_code);
51 #endif
52 static void bta_hl_sdp_cback(uint8_t sdp_op, uint8_t app_idx, uint8_t mcl_idx,
53 uint8_t mdl_idx, uint16_t status);
54 static void bta_hl_sdp_cback0(uint16_t status);
55 static void bta_hl_sdp_cback1(uint16_t status);
56 static void bta_hl_sdp_cback2(uint16_t status);
57 static void bta_hl_sdp_cback3(uint16_t status);
58 static void bta_hl_sdp_cback4(uint16_t status);
59 static void bta_hl_sdp_cback5(uint16_t status);
60 static void bta_hl_sdp_cback6(uint16_t status);
61
62 static tSDP_DISC_CMPL_CB* const bta_hl_sdp_cback_arr[] = {
63 bta_hl_sdp_cback0, bta_hl_sdp_cback1, bta_hl_sdp_cback2, bta_hl_sdp_cback3,
64 bta_hl_sdp_cback4, bta_hl_sdp_cback5, bta_hl_sdp_cback6};
65
66 /*******************************************************************************
67 *
68 * Function bta_hl_dch_mca_cong_change
69 *
70 * Description Action routine for processing congestion change notification
71 *
72 * Returns void
73 *
74 ******************************************************************************/
bta_hl_dch_mca_cong_change(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)75 void bta_hl_dch_mca_cong_change(uint8_t app_idx, uint8_t mcl_idx,
76 uint8_t mdl_idx, tBTA_HL_DATA* p_data) {
77 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
78 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
79 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
80 tMCA_CONG_CHG* p_cong_chg = &p_data->mca_evt.mca_data.cong_chg;
81 tBTA_HL evt_data;
82
83 #if (BTA_HL_DEBUG == TRUE)
84 APPL_TRACE_DEBUG("bta_hl_dch_mca_cong_change mdl_id=%d cong=%d",
85 p_cong_chg->mdl_id, p_cong_chg->cong);
86 #endif
87 evt_data.dch_cong_ind.cong = p_dcb->cong = p_cong_chg->cong;
88 evt_data.dch_cong_ind.mdl_handle = p_dcb->mdl_handle;
89 evt_data.dch_cong_ind.mcl_handle = p_mcb->mcl_handle;
90 evt_data.dch_cong_ind.app_handle = p_acb->app_handle;
91
92 p_acb->p_cback(BTA_HL_CONG_CHG_IND_EVT, (tBTA_HL*)&evt_data);
93 }
94
95 /*******************************************************************************
96 *
97 * Function bta_hl_dch_echo_test
98 *
99 * Description Action routine for processing echo test request
100 *
101 * Returns void
102 *
103 ******************************************************************************/
bta_hl_dch_echo_test(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,UNUSED_ATTR tBTA_HL_DATA * p_data)104 void bta_hl_dch_echo_test(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
105 UNUSED_ATTR tBTA_HL_DATA* p_data) {
106 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
107 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
108 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
109
110 #if (BTA_HL_DEBUG == TRUE)
111 APPL_TRACE_DEBUG("bta_hl_dch_echo_test");
112 #endif
113
114 p_dcb->echo_oper = BTA_HL_ECHO_OP_CI_GET_ECHO_DATA;
115 p_dcb->cout_oper |= BTA_HL_CO_GET_ECHO_DATA_MASK;
116
117 bta_hl_co_get_echo_data(
118 p_acb->app_id, p_mcb->mcl_handle, p_dcb->p_echo_tx_pkt->len,
119 BTA_HL_GET_BUF_PTR(p_dcb->p_echo_tx_pkt), BTA_HL_CI_GET_ECHO_DATA_EVT);
120 }
121 /*******************************************************************************
122 *
123 * Function bta_hl_dch_sdp_init
124 *
125 * Description Action routine for processing DCH SDP initiation
126 *
127 * Returns void
128 *
129 ******************************************************************************/
bta_hl_dch_sdp_init(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)130 void bta_hl_dch_sdp_init(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
131 tBTA_HL_DATA* p_data) {
132 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
133 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
134
135 #if (BTA_HL_DEBUG == TRUE)
136 APPL_TRACE_DEBUG("bta_hl_dch_sdp_init");
137 #endif
138 if (p_mcb->sdp_oper == BTA_HL_SDP_OP_NONE) {
139 p_mcb->sdp_mdl_idx = mdl_idx;
140 if (p_dcb->dch_oper == BTA_HL_DCH_OP_LOCAL_OPEN) {
141 p_mcb->sdp_oper = BTA_HL_SDP_OP_DCH_OPEN_INIT;
142
143 } else {
144 p_mcb->sdp_oper = BTA_HL_SDP_OP_DCH_RECONNECT_INIT;
145 }
146
147 if (bta_hl_init_sdp(p_mcb->sdp_oper, app_idx, mcl_idx, mdl_idx) !=
148 BTA_HL_STATUS_OK) {
149 APPL_TRACE_ERROR("SDP INIT failed");
150 p_mcb->sdp_oper = BTA_HL_SDP_OP_NONE;
151 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_SDP_FAIL_EVT,
152 p_data);
153 }
154 } else {
155 APPL_TRACE_ERROR("SDP in use");
156 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_SDP_FAIL_EVT,
157 p_data);
158 }
159 }
160
161 /*******************************************************************************
162 *
163 * Function bta_hl_dch_close_echo_test
164 *
165 * Description Action routine for processing the closing of echo test
166 *
167 * Returns void
168 *
169 ******************************************************************************/
bta_hl_dch_close_echo_test(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)170 void bta_hl_dch_close_echo_test(uint8_t app_idx, uint8_t mcl_idx,
171 uint8_t mdl_idx, tBTA_HL_DATA* p_data) {
172 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
173
174 #if (BTA_HL_DEBUG == TRUE)
175 APPL_TRACE_DEBUG("bta_hl_dch_close_echo_test");
176 #endif
177
178 switch (p_dcb->echo_oper) {
179 case BTA_HL_ECHO_OP_DCH_CLOSE_CFM:
180 case BTA_HL_ECHO_OP_OPEN_IND:
181 case BTA_HL_ECHO_OP_ECHO_PKT:
182 p_dcb->dch_oper = BTA_HL_DCH_OP_LOCAL_CLOSE_ECHO_TEST;
183 break;
184 case BTA_HL_ECHO_OP_MDL_CREATE_CFM:
185 case BTA_HL_ECHO_OP_DCH_OPEN_CFM:
186 case BTA_HL_ECHO_OP_LOOP_BACK:
187 default:
188 break;
189 }
190
191 if (MCA_CloseReq((tMCA_DL)p_dcb->mdl_handle) != MCA_SUCCESS) {
192 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT,
193 p_data);
194 }
195 }
196
197 /*******************************************************************************
198 *
199 * Function bta_hl_dch_mca_rcv_data
200 *
201 * Description Action routine for processing the received data
202 *
203 * Returns void
204 *
205 ******************************************************************************/
bta_hl_dch_mca_rcv_data(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)206 void bta_hl_dch_mca_rcv_data(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
207 tBTA_HL_DATA* p_data) {
208 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
209 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
210 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
211
212 #if (BTA_HL_DEBUG == TRUE)
213 APPL_TRACE_DEBUG("bta_hl_dch_mca_rcv_data");
214 #endif
215
216 if (p_dcb->local_mdep_id == BTA_HL_ECHO_TEST_MDEP_ID) {
217 switch (p_dcb->echo_oper) {
218 case BTA_HL_ECHO_OP_ECHO_PKT:
219
220 if (MCA_WriteReq((tMCA_DL)p_dcb->mdl_handle,
221 p_data->mca_rcv_data_evt.p_pkt) != MCA_SUCCESS) {
222 osi_free_and_reset((void**)&p_data->mca_rcv_data_evt.p_pkt);
223 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
224 BTA_HL_DCH_CLOSE_ECHO_TEST_EVT, p_data);
225 }
226 break;
227 case BTA_HL_ECHO_OP_LOOP_BACK:
228
229 p_dcb->p_echo_rx_pkt = p_data->mca_rcv_data_evt.p_pkt;
230 p_dcb->echo_oper = BTA_HL_ECHO_OP_CI_PUT_ECHO_DATA;
231 p_dcb->cout_oper |= BTA_HL_CO_PUT_ECHO_DATA_MASK;
232 p_dcb->ci_put_echo_data_status = BTA_HL_STATUS_FAIL;
233
234 bta_hl_co_put_echo_data(p_acb->app_id, p_mcb->mcl_handle,
235 p_dcb->p_echo_rx_pkt->len,
236 BTA_HL_GET_BUF_PTR(p_dcb->p_echo_rx_pkt),
237 BTA_HL_CI_PUT_ECHO_DATA_EVT);
238 break;
239 default:
240 APPL_TRACE_ERROR("Unknonw echo_oper=%d", p_dcb->echo_oper);
241 break;
242 }
243
244 } else {
245 p_dcb->cout_oper |= BTA_HL_CO_PUT_RX_DATA_MASK;
246 p_dcb->p_rx_pkt = p_data->mca_rcv_data_evt.p_pkt;
247
248 bta_hl_co_put_rx_data(
249 p_acb->app_id, p_dcb->mdl_handle, p_dcb->p_rx_pkt->len,
250 BTA_HL_GET_BUF_PTR(p_dcb->p_rx_pkt), BTA_HL_CI_PUT_RX_DATA_EVT);
251 }
252 }
253
254 /*******************************************************************************
255 *
256 * Function bta_hl_dch_ci_put_echo_data
257 *
258 * Description Action routine for processing the call-in of the
259 * put echo data event
260 *
261 * Returns void
262 *
263 ******************************************************************************/
bta_hl_dch_ci_put_echo_data(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)264 void bta_hl_dch_ci_put_echo_data(uint8_t app_idx, uint8_t mcl_idx,
265 uint8_t mdl_idx, tBTA_HL_DATA* p_data) {
266 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
267
268 #if (BTA_HL_DEBUG == TRUE)
269 APPL_TRACE_DEBUG("bta_hl_dch_ci_put_echo_data");
270 #endif
271
272 p_dcb->cout_oper &= ~BTA_HL_CO_PUT_ECHO_DATA_MASK;
273 osi_free_and_reset((void**)&p_dcb->p_echo_rx_pkt);
274 p_dcb->ci_put_echo_data_status = p_data->ci_get_put_echo_data.status;
275
276 p_dcb->echo_oper = BTA_HL_ECHO_OP_DCH_CLOSE_CFM;
277 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
278 BTA_HL_DCH_CLOSE_ECHO_TEST_EVT, p_data);
279 }
280
281 /*******************************************************************************
282 *
283 * Function bta_hl_dch_ci_get_echo_data
284 *
285 * Description Action routine for processing the call-in of the
286 * get echo data event
287 *
288 * Returns void
289 *
290 ******************************************************************************/
bta_hl_dch_ci_get_echo_data(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)291 void bta_hl_dch_ci_get_echo_data(uint8_t app_idx, uint8_t mcl_idx,
292 uint8_t mdl_idx, tBTA_HL_DATA* p_data) {
293 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
294 tBTA_HL_STATUS status;
295
296 #if (BTA_HL_DEBUG == TRUE)
297 APPL_TRACE_DEBUG("bta_hl_dch_ci_get_echo_data");
298 #endif
299
300 p_dcb->cout_oper &= ~BTA_HL_CO_GET_ECHO_DATA_MASK;
301
302 if (!p_dcb->abort_oper) {
303 status = p_data->ci_get_put_echo_data.status;
304 if (status == BTA_HL_STATUS_OK) {
305 p_dcb->echo_oper = BTA_HL_ECHO_OP_MDL_CREATE_CFM;
306 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_OPEN_EVT,
307 p_data);
308 } else {
309 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
310 BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
311 }
312 } else {
313 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT,
314 p_data);
315 }
316 }
317
318 /*******************************************************************************
319 *
320 * Function bta_hl_dch_ci_put_rx_data
321 *
322 * Description Action routine for processing the call-in of the
323 * put rx data event
324 *
325 * Returns void
326 *
327 ******************************************************************************/
bta_hl_dch_ci_put_rx_data(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)328 void bta_hl_dch_ci_put_rx_data(uint8_t app_idx, uint8_t mcl_idx,
329 uint8_t mdl_idx, tBTA_HL_DATA* p_data) {
330 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
331 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
332 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
333 tBTA_HL evt_data;
334
335 #if (BTA_HL_DEBUG == TRUE)
336 APPL_TRACE_DEBUG("bta_hl_dch_ci_put_rx_data");
337 #endif
338
339 p_dcb->cout_oper &= ~BTA_HL_CO_PUT_RX_DATA_MASK;
340 osi_free_and_reset((void**)&p_dcb->p_rx_pkt);
341 bta_hl_build_rcv_data_ind(&evt_data, p_acb->app_handle, p_mcb->mcl_handle,
342 p_dcb->mdl_handle);
343 p_acb->p_cback(BTA_HL_DCH_RCV_DATA_IND_EVT, (tBTA_HL*)&evt_data);
344 if (p_dcb->close_pending) {
345 if (!p_dcb->cout_oper) {
346 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_EVT,
347 p_data);
348 }
349 }
350 }
351
352 /*******************************************************************************
353 *
354 * Function bta_hl_dch_ci_get_tx_data
355 *
356 * Description Action routine for processing the call-in of the
357 * get tx data event
358 *
359 * Returns void
360 *
361 ******************************************************************************/
bta_hl_dch_ci_get_tx_data(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)362 void bta_hl_dch_ci_get_tx_data(uint8_t app_idx, uint8_t mcl_idx,
363 uint8_t mdl_idx, tBTA_HL_DATA* p_data) {
364 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
365 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
366 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
367 tMCA_RESULT result;
368 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
369 bool free_buf = false;
370 bool close_dch = false;
371 tBTA_HL evt_data;
372
373 #if (BTA_HL_DEBUG == TRUE)
374 APPL_TRACE_DEBUG("bta_hl_dch_ci_get_tx_data");
375 #endif
376
377 if (p_data != NULL) {
378 status = p_data->ci_get_put_data.status;
379 APPL_TRACE_WARNING("%s: status=%d", __func__, status);
380 }
381
382 p_dcb->cout_oper &= ~BTA_HL_CO_GET_TX_DATA_MASK;
383
384 if (p_dcb->close_pending) {
385 status = BTA_HL_STATUS_FAIL;
386 free_buf = true;
387
388 if (!p_dcb->cout_oper) {
389 close_dch = true;
390 }
391 } else if (status == BTA_HL_STATUS_FAIL) {
392 free_buf = TRUE;
393 } else {
394 result = MCA_WriteReq((tMCA_DL)p_dcb->mdl_handle, p_dcb->p_tx_pkt);
395 if (result != MCA_SUCCESS) {
396 if (result == MCA_BUSY) {
397 status = BTA_HL_STATUS_DCH_BUSY;
398 } else {
399 status = BTA_HL_STATUS_FAIL;
400 }
401 free_buf = true;
402 } else {
403 p_dcb->p_tx_pkt = NULL;
404 }
405 }
406
407 if (free_buf) osi_free_and_reset((void**)&p_dcb->p_tx_pkt);
408
409 bta_hl_build_send_data_cfm(&evt_data, p_acb->app_handle, p_mcb->mcl_handle,
410 p_dcb->mdl_handle, status);
411 p_acb->p_cback(BTA_HL_DCH_SEND_DATA_CFM_EVT, (tBTA_HL*)&evt_data);
412
413 if (close_dch) {
414 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_EVT,
415 p_data);
416 }
417 }
418
419 /*******************************************************************************
420 *
421 * Function bta_hl_dch_send_data
422 *
423 * Description Action routine for processing api send data request
424 *
425 * Returns void
426 *
427 ******************************************************************************/
bta_hl_dch_send_data(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)428 void bta_hl_dch_send_data(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
429 tBTA_HL_DATA* p_data) {
430 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
431 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
432 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
433 tBTA_HL evt_data;
434 bool success = true;
435
436 #if (BTA_HL_DEBUG == TRUE)
437 APPL_TRACE_DEBUG("bta_hl_dch_send_data");
438 #endif
439
440 if (!(p_dcb->cout_oper & BTA_HL_CO_GET_TX_DATA_MASK)) {
441 // p_dcb->chnl_cfg.fcs may be BTA_HL_MCA_USE_FCS (0x11) or BTA_HL_MCA_NO_FCS
442 // (0x10) or BTA_HL_DEFAULT_SOURCE_FCS (1)
443 bool fcs_use = (bool)(p_dcb->chnl_cfg.fcs & BTA_HL_MCA_FCS_USE_MASK);
444 p_dcb->p_tx_pkt = bta_hl_get_buf(p_data->api_send_data.pkt_size, fcs_use);
445 if (p_dcb->p_tx_pkt != NULL) {
446 bta_hl_co_get_tx_data(
447 p_acb->app_id, p_dcb->mdl_handle, p_data->api_send_data.pkt_size,
448 BTA_HL_GET_BUF_PTR(p_dcb->p_tx_pkt), BTA_HL_CI_GET_TX_DATA_EVT);
449 p_dcb->cout_oper |= BTA_HL_CO_GET_TX_DATA_MASK;
450 } else {
451 success = false;
452 }
453 } else {
454 success = false;
455 }
456
457 if (!success) {
458 bta_hl_build_send_data_cfm(&evt_data, p_acb->app_handle, p_mcb->mcl_handle,
459 p_dcb->mdl_handle, BTA_HL_STATUS_FAIL);
460 p_acb->p_cback(BTA_HL_DCH_SEND_DATA_CFM_EVT, (tBTA_HL*)&evt_data);
461 }
462 }
463
464 /*******************************************************************************
465 *
466 * Function bta_hl_dch_close_cmpl
467 *
468 * Description Action routine for processing the close complete event
469 *
470 * Returns void
471 *
472 ******************************************************************************/
bta_hl_dch_close_cmpl(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)473 void bta_hl_dch_close_cmpl(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
474 tBTA_HL_DATA* p_data) {
475 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
476 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
477 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
478 tBTA_HL evt_data;
479 tBTA_HL_EVT event = 0;
480 bool send_evt = true;
481 tBTA_HL_STATUS status;
482
483 #if (BTA_HL_DEBUG == TRUE)
484 APPL_TRACE_DEBUG("bta_hl_dch_close_cmpl dch oper=%s",
485 bta_hl_dch_oper_code(p_dcb->dch_oper));
486 #endif
487
488 switch (p_dcb->dch_oper) {
489 case BTA_HL_DCH_OP_LOCAL_OPEN:
490 case BTA_HL_DCH_OP_LOCAL_RECONNECT:
491
492 if (p_dcb->abort_oper & BTA_HL_ABORT_LOCAL_MASK) {
493 bta_hl_build_abort_cfm(&evt_data, p_acb->app_handle, p_mcb->mcl_handle,
494 BTA_HL_STATUS_OK);
495 event = BTA_HL_DCH_ABORT_CFM_EVT;
496 } else if (p_dcb->abort_oper & BTA_HL_ABORT_REMOTE_MASK) {
497 bta_hl_build_abort_ind(&evt_data, p_acb->app_handle, p_mcb->mcl_handle);
498 event = BTA_HL_DCH_ABORT_IND_EVT;
499 } else {
500 bta_hl_build_dch_open_cfm(&evt_data, p_acb->app_handle,
501 p_mcb->mcl_handle, BTA_HL_INVALID_MDL_HANDLE,
502 0, 0, 0, 0, 0, BTA_HL_STATUS_FAIL);
503 event = BTA_HL_DCH_OPEN_CFM_EVT;
504 if (p_dcb->dch_oper == BTA_HL_DCH_OP_LOCAL_RECONNECT) {
505 event = BTA_HL_DCH_RECONNECT_CFM_EVT;
506 }
507 }
508 break;
509
510 case BTA_HL_DCH_OP_LOCAL_CLOSE:
511 case BTA_HL_DCH_OP_REMOTE_DELETE:
512 case BTA_HL_DCH_OP_LOCAL_CLOSE_RECONNECT:
513 case BTA_HL_DCH_OP_NONE:
514
515 bta_hl_build_dch_close_cfm(&evt_data, p_acb->app_handle,
516 p_mcb->mcl_handle, p_dcb->mdl_handle,
517 BTA_HL_STATUS_OK);
518 event = BTA_HL_DCH_CLOSE_CFM_EVT;
519 break;
520
521 case BTA_HL_DCH_OP_REMOTE_CLOSE:
522 bta_hl_build_dch_close_ind(&evt_data, p_acb->app_handle,
523 p_mcb->mcl_handle, p_dcb->mdl_handle,
524 p_dcb->intentional_close);
525 event = BTA_HL_DCH_CLOSE_IND_EVT;
526 break;
527
528 case BTA_HL_DCH_OP_REMOTE_OPEN:
529
530 if (p_dcb->abort_oper & BTA_HL_ABORT_LOCAL_MASK) {
531 bta_hl_build_abort_cfm(&evt_data, p_acb->app_handle, p_mcb->mcl_handle,
532 BTA_HL_STATUS_OK);
533 event = BTA_HL_DCH_ABORT_CFM_EVT;
534 } else if (p_dcb->abort_oper & BTA_HL_ABORT_REMOTE_MASK) {
535 bta_hl_build_abort_ind(&evt_data, p_acb->app_handle, p_mcb->mcl_handle);
536 event = BTA_HL_DCH_ABORT_IND_EVT;
537 } else {
538 bta_hl_build_dch_close_ind(&evt_data, p_acb->app_handle,
539 p_mcb->mcl_handle, p_dcb->mdl_handle,
540 p_dcb->intentional_close);
541 event = BTA_HL_DCH_CLOSE_IND_EVT;
542 }
543 break;
544
545 case BTA_HL_DCH_OP_LOCAL_CLOSE_ECHO_TEST:
546 /* this is normal echo test close */
547 case BTA_HL_DCH_OP_REMOTE_CREATE:
548 case BTA_HL_DCH_OP_REMOTE_RECONNECT:
549 send_evt = false;
550 break;
551
552 default:
553 #if (BTA_HL_DEBUG == TRUE)
554 APPL_TRACE_ERROR("DCH operation not found oper=%s",
555 bta_hl_dch_oper_code(p_dcb->dch_oper));
556 #endif
557 send_evt = false;
558 break;
559 }
560
561 if (p_dcb->local_mdep_id == BTA_HL_ECHO_TEST_MDEP_ID) {
562 p_mcb->echo_test = false;
563 send_evt = false;
564
565 if (p_dcb->dch_oper != BTA_HL_DCH_OP_LOCAL_CLOSE_ECHO_TEST) {
566 switch (p_dcb->echo_oper) {
567 case BTA_HL_ECHO_OP_CI_GET_ECHO_DATA:
568 case BTA_HL_ECHO_OP_SDP_INIT:
569 case BTA_HL_ECHO_OP_MDL_CREATE_CFM:
570 case BTA_HL_ECHO_OP_DCH_OPEN_CFM:
571 case BTA_HL_ECHO_OP_LOOP_BACK:
572
573 status = BTA_HL_STATUS_FAIL;
574 send_evt = true;
575 break;
576 case BTA_HL_ECHO_OP_OPEN_IND:
577 case BTA_HL_ECHO_OP_ECHO_PKT:
578 break;
579 default:
580 APPL_TRACE_ERROR("Invalid echo_oper=%d", p_dcb->echo_oper);
581 break;
582 }
583 } else {
584 status = p_dcb->ci_put_echo_data_status;
585 send_evt = true;
586 }
587
588 if (send_evt) {
589 bta_hl_build_echo_test_cfm(&evt_data, p_acb->app_handle,
590 p_mcb->mcl_handle, status);
591 event = BTA_HL_DCH_ECHO_TEST_CFM_EVT;
592 }
593 }
594
595 bta_hl_clean_mdl_cb(app_idx, mcl_idx, mdl_idx);
596
597 if (send_evt) {
598 if (p_acb->p_cback) {
599 #if (BTA_HL_DEBUG == TRUE)
600 APPL_TRACE_DEBUG("Send Event: %s", bta_hl_cback_evt_code(event));
601 #endif
602 p_acb->p_cback(event, (tBTA_HL*)&evt_data);
603 }
604 }
605 /* check cch close is in progress or not */
606 bta_hl_check_cch_close(app_idx, mcl_idx, p_data, false);
607 }
608 /*******************************************************************************
609 *
610 * Function bta_hl_dch_mca_close_ind
611 *
612 * Description Action routine for processing the close indication
613 *
614 * Returns void
615 *
616 ******************************************************************************/
bta_hl_dch_mca_close_ind(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)617 void bta_hl_dch_mca_close_ind(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
618 tBTA_HL_DATA* p_data) {
619 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
620
621 #if (BTA_HL_DEBUG == TRUE)
622 APPL_TRACE_DEBUG("bta_hl_dch_mca_close_ind dch oper=%s",
623 bta_hl_dch_oper_code(p_dcb->dch_oper));
624 #endif
625
626 p_dcb->intentional_close = false;
627 if (p_data->mca_evt.mca_data.close_ind.reason == L2CAP_DISC_OK) {
628 p_dcb->intentional_close = true;
629 }
630
631 if (!p_dcb->cout_oper) {
632 if ((p_dcb->dch_oper != BTA_HL_DCH_OP_REMOTE_OPEN) &&
633 (p_dcb->dch_oper != BTA_HL_DCH_OP_REMOTE_RECONNECT)) {
634 p_dcb->dch_oper = BTA_HL_DCH_OP_REMOTE_CLOSE;
635 }
636 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT,
637 p_data);
638 } else {
639 p_dcb->close_pending = true;
640 }
641 }
642
643 /*******************************************************************************
644 *
645 * Function bta_hl_dch_mca_close_cfm
646 *
647 * Description Action routine for processing the close confirmation
648 *
649 * Returns void
650 *
651 ******************************************************************************/
bta_hl_dch_mca_close_cfm(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)652 void bta_hl_dch_mca_close_cfm(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
653 tBTA_HL_DATA* p_data) {
654 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
655
656 #if (BTA_HL_DEBUG == TRUE)
657 APPL_TRACE_DEBUG("bta_hl_dch_mca_close_cfm dch_oper=%s",
658 bta_hl_dch_oper_code(p_dcb->dch_oper));
659 #endif
660
661 switch (p_dcb->dch_oper) {
662 case BTA_HL_DCH_OP_LOCAL_CLOSE:
663 case BTA_HL_DCH_OP_LOCAL_OPEN:
664 case BTA_HL_DCH_OP_LOCAL_RECONNECT:
665 case BTA_HL_DCH_OP_LOCAL_CLOSE_ECHO_TEST:
666 case BTA_HL_DCH_OP_REMOTE_DELETE:
667 case BTA_HL_DCH_OP_LOCAL_CLOSE_RECONNECT:
668 case BTA_HL_DCH_OP_NONE:
669 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
670 BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
671 break;
672 default:
673 #if (BTA_HL_DEBUG == TRUE)
674 APPL_TRACE_ERROR("Invalid dch_oper=%s for close cfm",
675 bta_hl_dch_oper_code(p_dcb->dch_oper));
676 #endif
677 break;
678 }
679 }
680
681 /*******************************************************************************
682 *
683 * Function bta_hl_dch_mca_close
684 *
685 * Description Action routine for processing the DCH close request
686 *
687 * Returns void
688 *
689 ******************************************************************************/
bta_hl_dch_mca_close(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)690 void bta_hl_dch_mca_close(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
691 tBTA_HL_DATA* p_data) {
692 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
693 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
694 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
695 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
696 tBTA_HL evt_data;
697
698 #if (BTA_HL_DEBUG == TRUE)
699 APPL_TRACE_DEBUG("bta_hl_dch_mca_close");
700 #endif
701 if (!p_dcb->cout_oper) {
702 p_dcb->close_pending = false;
703 if (MCA_CloseReq((tMCA_DL)p_dcb->mdl_handle) == MCA_SUCCESS) {
704 p_dcb->dch_oper = BTA_HL_DCH_OP_LOCAL_CLOSE;
705 } else {
706 status = BTA_HL_STATUS_FAIL;
707 }
708
709 if ((status != BTA_HL_STATUS_OK) &&
710 (p_mcb->cch_close_dch_oper != BTA_HL_CCH_CLOSE_OP_DCH_CLOSE)) {
711 bta_hl_build_dch_close_cfm(&evt_data, p_acb->app_handle,
712 p_mcb->mcl_handle,
713 p_data->api_dch_close.mdl_handle, status);
714 p_acb->p_cback(BTA_HL_DCH_CLOSE_CFM_EVT, (tBTA_HL*)&evt_data);
715 }
716 } else {
717 p_dcb->close_pending = true;
718 }
719 }
720
721 /*******************************************************************************
722 *
723 * Function bta_hl_dch_mca_open_ind
724 *
725 * Description Action routine for processing the open indication
726 *
727 * Returns void
728 *
729 ******************************************************************************/
bta_hl_dch_mca_open_ind(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)730 void bta_hl_dch_mca_open_ind(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
731 tBTA_HL_DATA* p_data) {
732 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
733 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
734 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
735 tMCA_DL_OPEN* p_open_ind = &p_data->mca_evt.mca_data.open_ind;
736 tBTA_HL evt_data;
737 tBTA_HL_EVT event;
738 uint8_t old_dch_oper = BTA_HL_DCH_OP_NONE;
739 bool send_event = false;
740
741 #if (BTA_HL_DEBUG == TRUE)
742 APPL_TRACE_DEBUG("bta_hl_dch_mca_open_ind");
743 #endif
744 if ((p_dcb->dch_oper == BTA_HL_DCH_OP_REMOTE_OPEN) ||
745 (p_dcb->dch_oper == BTA_HL_DCH_OP_REMOTE_RECONNECT)) {
746 p_dcb->mdl_handle = (tBTA_HL_MDL_HANDLE)p_open_ind->mdl;
747 p_dcb->mtu = p_open_ind->mtu;
748
749 evt_data.dch_open_ind.mdl_handle = p_dcb->mdl_handle;
750 evt_data.dch_open_ind.mcl_handle = p_mcb->mcl_handle;
751 evt_data.dch_open_ind.app_handle = p_acb->app_handle;
752
753 evt_data.dch_open_ind.local_mdep_id = p_dcb->local_mdep_id;
754 evt_data.dch_open_ind.mdl_id = p_dcb->mdl_id;
755 evt_data.dch_open_ind.mtu = p_dcb->mtu;
756
757 if (p_dcb->chnl_cfg.fcr_opt.mode == L2CAP_FCR_ERTM_MODE) {
758 evt_data.dch_open_ind.dch_mode = BTA_HL_DCH_MODE_RELIABLE;
759 if (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx)) {
760 p_dcb->is_the_first_reliable = true;
761 }
762 } else {
763 evt_data.dch_open_ind.dch_mode = BTA_HL_DCH_MODE_STREAMING;
764 }
765 evt_data.dch_open_ind.first_reliable = p_dcb->is_the_first_reliable;
766
767 old_dch_oper = p_dcb->dch_oper;
768 p_dcb->dch_oper = BTA_HL_DCH_OP_NONE;
769 }
770
771 switch (old_dch_oper) {
772 case BTA_HL_DCH_OP_REMOTE_OPEN:
773
774 p_dcb->dch_mode = evt_data.dch_open_ind.dch_mode;
775 if (p_dcb->local_mdep_id != BTA_HL_ECHO_TEST_MDEP_ID) {
776 bta_hl_save_mdl_cfg(app_idx, mcl_idx, mdl_idx);
777 event = BTA_HL_DCH_OPEN_IND_EVT;
778 send_event = true;
779 } else {
780 p_dcb->echo_oper = BTA_HL_ECHO_OP_ECHO_PKT;
781 }
782
783 break;
784
785 case BTA_HL_DCH_OP_REMOTE_RECONNECT:
786
787 if (bta_hl_validate_chan_cfg(app_idx, mcl_idx, mdl_idx)) {
788 bta_hl_save_mdl_cfg(app_idx, mcl_idx, mdl_idx);
789 event = BTA_HL_DCH_RECONNECT_IND_EVT;
790 send_event = true;
791 } else {
792 if (MCA_CloseReq((tMCA_DL)p_dcb->mdl_handle) == MCA_SUCCESS) {
793 p_dcb->dch_oper = BTA_HL_DCH_OP_LOCAL_CLOSE_RECONNECT;
794 } else {
795 APPL_TRACE_ERROR("Unabel to close DCH for reconnect cfg mismatch");
796 }
797 }
798 break;
799 default:
800 break;
801 }
802
803 if (send_event) {
804 p_acb->p_cback(event, (tBTA_HL*)&evt_data);
805 }
806 }
807
808 /*******************************************************************************
809 *
810 * Function bta_hl_dch_mca_open_cfm
811 *
812 * Description Action routine for processing the open confirmation
813 *
814 * Returns void
815 *
816 ******************************************************************************/
bta_hl_dch_mca_open_cfm(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)817 void bta_hl_dch_mca_open_cfm(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
818 tBTA_HL_DATA* p_data) {
819 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
820 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
821 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
822 tMCA_DL_OPEN* p_open_cfm = &p_data->mca_evt.mca_data.open_cfm;
823 tBTA_HL evt_data;
824 tBTA_HL_EVT event;
825 uint8_t old_dch_oper = BTA_HL_DCH_OP_NONE;
826 tBTA_HL_DCH_MODE dch_mode = BTA_HL_DCH_MODE_STREAMING;
827 bool send_event = false;
828
829 #if (BTA_HL_DEBUG == TRUE)
830 APPL_TRACE_DEBUG("bta_hl_dch_mca_open_cfm");
831 #endif
832 if ((p_dcb->dch_oper == BTA_HL_DCH_OP_LOCAL_OPEN) ||
833 (p_dcb->dch_oper == BTA_HL_DCH_OP_LOCAL_RECONNECT)) {
834 p_dcb->mdl_handle = (tBTA_HL_MDL_HANDLE)p_open_cfm->mdl;
835 p_dcb->mtu = p_open_cfm->mtu;
836
837 /*todo verify dch_mode, mtu and fcs for reconnect */
838 if (p_dcb->chnl_cfg.fcr_opt.mode == L2CAP_FCR_ERTM_MODE) {
839 dch_mode = BTA_HL_DCH_MODE_RELIABLE;
840 }
841
842 if (p_dcb->local_mdep_id != BTA_HL_ECHO_TEST_MDEP_ID) {
843 if (dch_mode == BTA_HL_DCH_MODE_RELIABLE) {
844 if (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx)) {
845 p_dcb->is_the_first_reliable = true;
846 }
847 }
848 }
849
850 bta_hl_build_dch_open_cfm(
851 &evt_data, p_acb->app_handle, p_mcb->mcl_handle, p_dcb->mdl_handle,
852 p_dcb->local_mdep_id, p_dcb->mdl_id, dch_mode,
853 p_dcb->is_the_first_reliable, p_dcb->mtu, BTA_HL_STATUS_OK);
854
855 old_dch_oper = p_dcb->dch_oper;
856 p_dcb->dch_oper = BTA_HL_DCH_OP_NONE;
857 } else {
858 APPL_TRACE_ERROR("Error dch oper =%d", p_dcb->dch_oper);
859 return;
860 }
861
862 switch (old_dch_oper) {
863 case BTA_HL_DCH_OP_LOCAL_OPEN:
864
865 p_dcb->dch_mode = dch_mode;
866 if (p_dcb->local_mdep_id != BTA_HL_ECHO_TEST_MDEP_ID) {
867 bta_hl_save_mdl_cfg(app_idx, mcl_idx, mdl_idx);
868 event = BTA_HL_DCH_OPEN_CFM_EVT;
869 send_event = true;
870 } else {
871 p_dcb->echo_oper = BTA_HL_ECHO_OP_LOOP_BACK;
872 if (MCA_WriteReq((tMCA_DL)p_dcb->mdl_handle, p_dcb->p_echo_tx_pkt) !=
873 MCA_SUCCESS) {
874 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
875 BTA_HL_DCH_CLOSE_ECHO_TEST_EVT, p_data);
876 } else {
877 p_dcb->p_echo_tx_pkt = NULL;
878 }
879 }
880 break;
881
882 case BTA_HL_DCH_OP_LOCAL_RECONNECT:
883
884 if (bta_hl_validate_chan_cfg(app_idx, mcl_idx, mdl_idx)) {
885 bta_hl_save_mdl_cfg(app_idx, mcl_idx, mdl_idx);
886 event = BTA_HL_DCH_RECONNECT_CFM_EVT;
887 send_event = true;
888 } else {
889 if (MCA_CloseReq((tMCA_DL)p_dcb->mdl_handle) == MCA_SUCCESS) {
890 p_dcb->dch_oper = BTA_HL_DCH_OP_LOCAL_CLOSE_RECONNECT;
891 } else {
892 APPL_TRACE_ERROR("Unabel to close DCH for reconnect cfg mismatch");
893 }
894 }
895 break;
896 default:
897 break;
898 }
899
900 if (send_event) p_acb->p_cback(event, (tBTA_HL*)&evt_data);
901 }
902
903 /*******************************************************************************
904 *
905 * Function bta_hl_dch_mca_abort_ind
906 *
907 * Description Action routine for processing the abort indication
908 *
909 * Returns void
910 *
911 ******************************************************************************/
bta_hl_dch_mca_abort_ind(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)912 void bta_hl_dch_mca_abort_ind(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
913 tBTA_HL_DATA* p_data) {
914 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
915
916 #if (BTA_HL_DEBUG == TRUE)
917 APPL_TRACE_DEBUG("bta_hl_dch_mca_abort_ind");
918 #endif
919
920 p_dcb->abort_oper |= BTA_HL_ABORT_REMOTE_MASK;
921 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT,
922 p_data);
923 }
924
925 /*******************************************************************************
926 *
927 * Function bta_hl_dch_mca_abort_cfm
928 *
929 * Description Action routine for processing the abort confirmation
930 *
931 * Returns void
932 *
933 ******************************************************************************/
bta_hl_dch_mca_abort_cfm(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)934 void bta_hl_dch_mca_abort_cfm(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
935 tBTA_HL_DATA* p_data) {
936 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
937 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
938 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
939 tBTA_HL evt_data;
940
941 #if (BTA_HL_DEBUG == TRUE)
942 APPL_TRACE_DEBUG("bta_hl_dch_mca_abort_cfm");
943 #endif
944
945 if (p_dcb->abort_oper) {
946 if (p_data->mca_evt.mca_data.abort_cfm.rsp_code != MCA_RSP_SUCCESS) {
947 if (p_dcb->abort_oper & BTA_HL_ABORT_LOCAL_MASK) {
948 bta_hl_build_abort_cfm(&evt_data, p_acb->app_handle, p_mcb->mcl_handle,
949 BTA_HL_STATUS_FAIL);
950 p_acb->p_cback(BTA_HL_DCH_ABORT_CFM_EVT, (tBTA_HL*)&evt_data);
951 }
952 } else {
953 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
954 BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
955 }
956 } else {
957 APPL_TRACE_ERROR("Not expecting Abort CFM ");
958 }
959 }
960
961 /*******************************************************************************
962 *
963 * Function bta_hl_dch_mca_abort
964 *
965 * Description Action routine for processing the abort request
966 *
967 * Returns void
968 *
969 ******************************************************************************/
bta_hl_dch_mca_abort(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)970 void bta_hl_dch_mca_abort(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
971 tBTA_HL_DATA* p_data) {
972 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
973 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
974 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
975 tMCA_RESULT mca_result;
976 tBTA_HL evt_data;
977
978 if (((p_mcb->sdp_oper == BTA_HL_SDP_OP_DCH_OPEN_INIT) ||
979 (p_mcb->sdp_oper == BTA_HL_SDP_OP_DCH_RECONNECT_INIT)) &&
980 (p_mcb->sdp_mdl_idx == mdl_idx)) {
981 p_dcb->abort_oper |= BTA_HL_ABORT_PENDING_MASK;
982 return;
983 } else if (p_dcb->echo_oper == BTA_HL_ECHO_OP_CI_GET_ECHO_DATA) {
984 p_dcb->abort_oper |= BTA_HL_ABORT_PENDING_MASK;
985 return;
986 }
987
988 p_dcb->abort_oper &= ~BTA_HL_ABORT_PENDING_MASK;
989
990 mca_result = MCA_Abort((tMCA_CL)p_mcb->mcl_handle);
991 if (mca_result != MCA_SUCCESS) {
992 if (mca_result == MCA_NO_RESOURCES) {
993 p_dcb->abort_oper |= BTA_HL_ABORT_PENDING_MASK;
994 } else {
995 if (p_dcb->abort_oper & BTA_HL_ABORT_LOCAL_MASK) {
996 bta_hl_build_abort_cfm(&evt_data, p_acb->app_handle, p_mcb->mcl_handle,
997 BTA_HL_STATUS_FAIL);
998 p_acb->p_cback(BTA_HL_DCH_ABORT_CFM_EVT, (tBTA_HL*)&evt_data);
999 }
1000 bta_hl_check_cch_close(app_idx, mcl_idx, p_data, false);
1001 }
1002 }
1003
1004 #if (BTA_HL_DEBUG == TRUE)
1005 APPL_TRACE_DEBUG("bta_hl_dch_mca_abort abort_oper=0x%x", p_dcb->abort_oper);
1006 #endif
1007 }
1008
1009 /*******************************************************************************
1010 *
1011 * Function bta_hl_dch_mca_reconnect_ind
1012 *
1013 * Description Action routine for processing the reconnect indication
1014 *
1015 * Returns void
1016 *
1017 ******************************************************************************/
bta_hl_dch_mca_reconnect_ind(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)1018 void bta_hl_dch_mca_reconnect_ind(uint8_t app_idx, uint8_t mcl_idx,
1019 uint8_t mdl_idx, tBTA_HL_DATA* p_data) {
1020 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1021 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1022 tBTA_HL_MDL_CFG* p_mdl_cfg;
1023 tMCA_EVT_HDR* p_reconnect_ind = &p_data->mca_evt.mca_data.reconnect_ind;
1024 uint8_t mdl_cfg_idx, in_use_mdl_idx, mdep_cfg_idx;
1025 uint8_t rsp_code = MCA_RSP_SUCCESS;
1026
1027 #if (BTA_HL_DEBUG == TRUE)
1028 APPL_TRACE_DEBUG("bta_hl_dch_mca_reconnect_ind mdl_id=%d",
1029 p_reconnect_ind->mdl_id);
1030 #endif
1031
1032 if (bta_hl_find_mdl_cfg_idx(app_idx, mcl_idx, p_reconnect_ind->mdl_id,
1033 &mdl_cfg_idx)) {
1034 if (!bta_hl_find_mdl_idx(app_idx, mcl_idx, p_reconnect_ind->mdl_id,
1035 &in_use_mdl_idx)) {
1036 p_mdl_cfg = BTA_HL_GET_MDL_CFG_PTR(app_idx, mdl_cfg_idx);
1037
1038 if (bta_hl_find_mdep_cfg_idx(app_idx, p_mdl_cfg->local_mdep_id,
1039 &mdep_cfg_idx)) {
1040 p_dcb->in_use = true;
1041 p_dcb->dch_oper = BTA_HL_DCH_OP_REMOTE_RECONNECT;
1042 p_dcb->sec_mask = (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT);
1043 p_dcb->peer_mdep_id = 0xFF;
1044 p_dcb->local_mdep_id = p_mdl_cfg->local_mdep_id;
1045 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx;
1046 p_dcb->local_cfg = BTA_HL_DCH_CFG_UNKNOWN;
1047 p_dcb->mdl_id = p_reconnect_ind->mdl_id;
1048 p_dcb->mdl_cfg_idx_included = true;
1049 p_dcb->mdl_cfg_idx = mdl_cfg_idx;
1050 p_dcb->dch_mode = p_mdl_cfg->dch_mode;
1051 bta_hl_find_rxtx_apdu_size(app_idx, mdep_cfg_idx,
1052 &p_dcb->max_rx_apdu_size,
1053 &p_dcb->max_tx_apdu_size);
1054 bta_hl_set_dch_chan_cfg(app_idx, mcl_idx, mdl_idx, p_data);
1055 } else {
1056 rsp_code = MCA_RSP_BAD_MDL;
1057 }
1058 } else {
1059 rsp_code = MCA_RSP_BAD_MDL;
1060 }
1061 } else {
1062 rsp_code = MCA_RSP_BAD_MDL;
1063 }
1064
1065 if (MCA_ReconnectMdlRsp((tMCA_CL)p_mcb->mcl_handle, p_dcb->local_mdep_id,
1066 p_dcb->mdl_id, rsp_code,
1067 &p_dcb->chnl_cfg) != MCA_SUCCESS) {
1068 MCA_Abort((tMCA_CL)p_mcb->mcl_handle);
1069 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT,
1070 p_data);
1071 }
1072 }
1073
1074 /*******************************************************************************
1075 *
1076 * Function bta_hl_dch_mca_reconnect_cfm
1077 *
1078 * Description Action routine for processing the reconenct confirmation
1079 *
1080 * Returns void
1081 *
1082 ******************************************************************************/
bta_hl_dch_mca_reconnect_cfm(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)1083 void bta_hl_dch_mca_reconnect_cfm(uint8_t app_idx, uint8_t mcl_idx,
1084 uint8_t mdl_idx, tBTA_HL_DATA* p_data) {
1085 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1086 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1087 tMCA_RSP_EVT* p_reconnect_cfm = &p_data->mca_evt.mca_data.reconnect_cfm;
1088
1089 #if (BTA_HL_DEBUG == TRUE)
1090 APPL_TRACE_DEBUG("bta_hl_dch_mca_reconnect_cfm");
1091 #endif
1092 if (p_dcb->abort_oper & BTA_HL_ABORT_PENDING_MASK) {
1093 p_dcb->abort_oper &= ~BTA_HL_ABORT_PENDING_MASK;
1094 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_ABORT_EVT,
1095 p_data);
1096 return;
1097 }
1098
1099 if (p_dcb->dch_oper == BTA_HL_DCH_OP_LOCAL_RECONNECT) {
1100 if (p_reconnect_cfm->rsp_code == MCA_RSP_SUCCESS) {
1101 bta_hl_set_dch_chan_cfg(app_idx, mcl_idx, mdl_idx, p_data);
1102
1103 if (MCA_DataChnlCfg((tMCA_CL)p_mcb->mcl_handle, &p_dcb->chnl_cfg) !=
1104 MCA_SUCCESS) {
1105 /* should be able to abort so no checking of the return code */
1106 MCA_Abort((tMCA_CL)p_mcb->mcl_handle);
1107 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
1108 BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
1109 }
1110 } else {
1111 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
1112 BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
1113 }
1114 }
1115 }
1116
1117 /*******************************************************************************
1118 *
1119 * Function bta_hl_dch_mca_reconnect
1120 *
1121 * Description Action routine for processing the reconnect request
1122 *
1123 * Returns void
1124 *
1125 ******************************************************************************/
bta_hl_dch_mca_reconnect(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)1126 void bta_hl_dch_mca_reconnect(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
1127 tBTA_HL_DATA* p_data) {
1128 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1129 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1130 tMCA_CHNL_CFG* p_chnl_cfg = NULL;
1131 uint8_t sdp_idx;
1132
1133 #if (BTA_HL_DEBUG == TRUE)
1134 APPL_TRACE_DEBUG("bta_hl_dch_mca_reconnect");
1135 #endif
1136 if (bta_hl_find_sdp_idx_using_ctrl_psm(&p_mcb->sdp, p_mcb->ctrl_psm,
1137 &sdp_idx)) {
1138 p_mcb->data_psm = p_mcb->sdp.sdp_rec[sdp_idx].data_psm;
1139 if (MCA_ReconnectMdl((tMCA_CL)p_mcb->mcl_handle, p_dcb->local_mdep_id,
1140 p_mcb->data_psm, p_dcb->mdl_id,
1141 p_chnl_cfg) != MCA_SUCCESS) {
1142 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
1143 BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
1144 }
1145 } else {
1146 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT,
1147 p_data);
1148 }
1149 }
1150
1151 /*******************************************************************************
1152 *
1153 * Function bta_hl_dch_create_rsp
1154 *
1155 * Description Action routine for processing BTA_HL_API_DCH_CREATE_RSP_EVT
1156 *
1157 * Returns void
1158 *
1159 ******************************************************************************/
bta_hl_dch_create_rsp(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)1160 void bta_hl_dch_create_rsp(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
1161 tBTA_HL_DATA* p_data) {
1162 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1163 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1164 tBTA_HL_API_DCH_CREATE_RSP* p_create_rsp = &p_data->api_dch_create_rsp;
1165 uint8_t mca_rsp_code = MCA_RSP_SUCCESS;
1166
1167 #if (BTA_HL_DEBUG == TRUE)
1168 APPL_TRACE_DEBUG("bta_hl_dch_create_rsp");
1169 #endif
1170 if (p_create_rsp->rsp_code == BTA_HL_DCH_CREATE_RSP_SUCCESS) {
1171 p_dcb->dch_oper = BTA_HL_DCH_OP_REMOTE_OPEN;
1172 p_dcb->local_cfg = p_create_rsp->cfg_rsp;
1173
1174 bta_hl_set_dch_chan_cfg(app_idx, mcl_idx, mdl_idx, p_data);
1175 } else {
1176 mca_rsp_code = MCA_RSP_CFG_REJ;
1177 }
1178
1179 if (MCA_CreateMdlRsp((tMCA_CL)p_mcb->mcl_handle, p_dcb->local_mdep_id,
1180 p_dcb->mdl_id, p_dcb->local_cfg, mca_rsp_code,
1181 &p_dcb->chnl_cfg) != MCA_SUCCESS) {
1182 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT,
1183 p_data);
1184 }
1185 }
1186
1187 /*******************************************************************************
1188 *
1189 * Function bta_hl_dch_mca_create_ind
1190 *
1191 * Description Action routine for processing
1192 *
1193 * Returns void
1194 *
1195 ******************************************************************************/
bta_hl_dch_mca_create_ind(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)1196 void bta_hl_dch_mca_create_ind(uint8_t app_idx, uint8_t mcl_idx,
1197 uint8_t mdl_idx, tBTA_HL_DATA* p_data) {
1198 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1199 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1200 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1201 tMCA_CREATE_IND* p_create_ind = &p_data->mca_evt.mca_data.create_ind;
1202 uint8_t mdep_cfg_idx;
1203 uint8_t cfg_rsp;
1204 uint8_t rsp_code = MCA_RSP_SUCCESS;
1205 bool send_create_ind_evt = false;
1206 tBTA_HL evt_data;
1207 tBTA_HL_ECHO_CFG* p_echo_cfg;
1208
1209 #if (BTA_HL_DEBUG == TRUE)
1210 APPL_TRACE_DEBUG("bta_hl_dch_mca_create_ind");
1211 #endif
1212
1213 if (bta_hl_find_mdep_cfg_idx(app_idx, p_create_ind->dep_id, &mdep_cfg_idx)) {
1214 if (p_create_ind->dep_id == BTA_HL_ECHO_TEST_MDEP_ID) {
1215 if (bta_hl_find_echo_cfg_rsp(app_idx, mcl_idx, mdep_cfg_idx,
1216 p_create_ind->cfg, &cfg_rsp)) {
1217 p_dcb->in_use = true;
1218 p_dcb->dch_oper = BTA_HL_DCH_OP_REMOTE_OPEN;
1219 p_dcb->local_mdep_id = p_create_ind->dep_id;
1220 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx;
1221 p_dcb->local_cfg = cfg_rsp;
1222 p_dcb->remote_cfg = p_create_ind->cfg;
1223 p_dcb->mdl_id = p_create_ind->mdl_id;
1224 p_dcb->mdl_cfg_idx_included = false;
1225 p_echo_cfg = BTA_HL_GET_ECHO_CFG_PTR(app_idx);
1226 p_dcb->max_rx_apdu_size = p_echo_cfg->max_rx_apdu_size;
1227 p_dcb->max_tx_apdu_size = p_echo_cfg->max_tx_apdu_size;
1228
1229 bta_hl_set_dch_chan_cfg(app_idx, mcl_idx, mdl_idx, p_data);
1230 } else {
1231 rsp_code = MCA_RSP_CFG_REJ;
1232 }
1233 } else
1234
1235 {
1236 p_dcb->in_use = true;
1237 p_dcb->dch_oper = BTA_HL_DCH_OP_REMOTE_CREATE;
1238 p_dcb->local_mdep_id = p_create_ind->dep_id;
1239 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx;
1240 p_dcb->local_cfg = BTA_HL_DCH_CFG_UNKNOWN;
1241 p_dcb->remote_cfg = p_create_ind->cfg;
1242 p_dcb->mdl_id = p_create_ind->mdl_id;
1243 p_dcb->mdl_cfg_idx_included = false;
1244 bta_hl_find_rxtx_apdu_size(app_idx, mdep_cfg_idx,
1245 &p_dcb->max_rx_apdu_size,
1246 &p_dcb->max_tx_apdu_size);
1247 send_create_ind_evt = true;
1248 }
1249 } else {
1250 rsp_code = MCA_RSP_BAD_MDEP;
1251 }
1252
1253 if (send_create_ind_evt) {
1254 evt_data.dch_create_ind.mcl_handle = p_mcb->mcl_handle;
1255 evt_data.dch_create_ind.app_handle = p_acb->app_handle;
1256 evt_data.dch_create_ind.local_mdep_id = p_dcb->local_mdep_id;
1257 evt_data.dch_create_ind.mdl_id = p_dcb->mdl_id;
1258 evt_data.dch_create_ind.cfg = p_dcb->remote_cfg;
1259 evt_data.dch_create_ind.bd_addr = p_mcb->bd_addr;
1260 p_acb->p_cback(BTA_HL_DCH_CREATE_IND_EVT, (tBTA_HL*)&evt_data);
1261 } else {
1262 if (MCA_CreateMdlRsp((tMCA_CL)p_mcb->mcl_handle, p_dcb->local_mdep_id,
1263 p_dcb->mdl_id, p_dcb->local_cfg, rsp_code,
1264 &p_dcb->chnl_cfg) != MCA_SUCCESS) {
1265 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
1266 BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
1267 } else {
1268 if (p_dcb->local_mdep_id == BTA_HL_ECHO_TEST_MDEP_ID) {
1269 p_mcb->echo_test = true;
1270 p_dcb->echo_oper = BTA_HL_ECHO_OP_OPEN_IND;
1271 }
1272 }
1273 }
1274 }
1275
1276 /*******************************************************************************
1277 *
1278 * Function bta_hl_dch_mca_create_cfm
1279 *
1280 * Description Action routine for processing
1281 *
1282 * Returns void
1283 *
1284 ******************************************************************************/
bta_hl_dch_mca_create_cfm(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)1285 void bta_hl_dch_mca_create_cfm(uint8_t app_idx, uint8_t mcl_idx,
1286 uint8_t mdl_idx, tBTA_HL_DATA* p_data) {
1287 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1288 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1289 tMCA_CREATE_CFM* p_create_cfm = &p_data->mca_evt.mca_data.create_cfm;
1290
1291 #if (BTA_HL_DEBUG == TRUE)
1292 APPL_TRACE_DEBUG("bta_hl_dch_mca_create_cfm");
1293 #endif
1294
1295 if (p_dcb->abort_oper & BTA_HL_ABORT_PENDING_MASK) {
1296 p_dcb->abort_oper &= ~BTA_HL_ABORT_PENDING_MASK;
1297 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_ABORT_EVT,
1298 p_data);
1299 return;
1300 }
1301
1302 if (p_dcb->dch_oper == BTA_HL_DCH_OP_LOCAL_OPEN) {
1303 if (p_create_cfm->rsp_code == MCA_RSP_SUCCESS) {
1304 if (bta_hl_validate_cfg(app_idx, mcl_idx, mdl_idx, p_create_cfm->cfg)) {
1305 bta_hl_set_dch_chan_cfg(app_idx, mcl_idx, mdl_idx, p_data);
1306
1307 if (MCA_DataChnlCfg((tMCA_CL)p_mcb->mcl_handle, &p_dcb->chnl_cfg) !=
1308 MCA_SUCCESS) {
1309 /* this should not happen */
1310 APPL_TRACE_ERROR("Unable to create data channel");
1311 MCA_Abort((tMCA_CL)p_mcb->mcl_handle);
1312 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
1313 BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
1314 } else {
1315 if (p_dcb->local_mdep_id == BTA_HL_ECHO_TEST_MDEP_ID) {
1316 p_dcb->echo_oper = BTA_HL_ECHO_OP_DCH_OPEN_CFM;
1317 }
1318 }
1319 } else {
1320 MCA_Abort((tMCA_CL)p_mcb->mcl_handle);
1321 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
1322 BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
1323 }
1324 } else {
1325 APPL_TRACE_ERROR("MCA Create- failed");
1326 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
1327 BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
1328 }
1329 }
1330 }
1331
1332 /*******************************************************************************
1333 *
1334 * Function bta_hl_dch_mca_create
1335 *
1336 * Description Action routine for processing the MDL create request
1337 *
1338 * Returns void
1339 *
1340 ******************************************************************************/
bta_hl_dch_mca_create(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)1341 void bta_hl_dch_mca_create(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
1342 tBTA_HL_DATA* p_data) {
1343 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1344 tBTA_HL_MDL_CB* p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1345 tMCA_RESULT result;
1346 uint8_t sdp_idx;
1347
1348 #if (BTA_HL_DEBUG == TRUE)
1349 APPL_TRACE_DEBUG("bta_hl_dch_mca_create");
1350 #endif
1351
1352 if (bta_hl_find_sdp_idx_using_ctrl_psm(&p_mcb->sdp, p_mcb->ctrl_psm,
1353 &sdp_idx) &&
1354 bta_hl_validate_peer_cfg(app_idx, mcl_idx, mdl_idx, p_dcb->peer_mdep_id,
1355 p_dcb->peer_mdep_role, sdp_idx)) {
1356 p_mcb->data_psm = p_mcb->sdp.sdp_rec[sdp_idx].data_psm;
1357 result = MCA_CreateMdl((tMCA_CL)p_mcb->mcl_handle, p_dcb->local_mdep_id,
1358 p_mcb->data_psm, p_dcb->mdl_id, p_dcb->peer_mdep_id,
1359 p_dcb->local_cfg, NULL);
1360 if (result != MCA_SUCCESS) {
1361 APPL_TRACE_ERROR("MCA_CreateMdl FAIL mca_result=%d", result);
1362 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
1363 BTA_HL_DCH_CLOSE_CMPL_EVT, p_data);
1364 }
1365 } else {
1366 APPL_TRACE_ERROR("MCA Create- SDP idx or peer MDEP cfg not found");
1367 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT,
1368 p_data);
1369 }
1370 }
1371
1372 /*******************************************************************************
1373 *
1374 * Function bta_hl_dch_sdp_fail
1375 *
1376 * Description Action routine for processing the SDP failed event
1377 *
1378 * Returns void
1379 *
1380 ******************************************************************************/
bta_hl_dch_sdp_fail(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,tBTA_HL_DATA * p_data)1381 void bta_hl_dch_sdp_fail(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
1382 tBTA_HL_DATA* p_data) {
1383 #if (BTA_HL_DEBUG == TRUE)
1384 APPL_TRACE_DEBUG("bta_hl_dch_sdp_fail");
1385 #endif
1386 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_CMPL_EVT,
1387 p_data);
1388 }
1389
1390 /******************************************************************************
1391 *
1392 * Function bta_hl_sdp_cback
1393 *
1394 * Description This is the SDP callback function used by HL.
1395 * This function will be executed by SDP when the service
1396 * search is completed. If the search is successful, it
1397 * finds the first record in the database that matches the
1398 * UUID of the search. Then retrieves the scn from the
1399 * record.
1400 *
1401 * Returns void.
1402 *
1403 *****************************************************************************/
bta_hl_sdp_cback(uint8_t sdp_oper,uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,uint16_t status)1404 static void bta_hl_sdp_cback(uint8_t sdp_oper, uint8_t app_idx, uint8_t mcl_idx,
1405 uint8_t mdl_idx, uint16_t status) {
1406 tBTA_HL_MCL_CB* p_cb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1407 tBTA_HL_SDP_REC* p_hdp_rec;
1408 tBTA_HL_CCH_SDP* p_cch_buf;
1409 tBTA_HL_DCH_SDP* p_dch_buf;
1410 tSDP_DISC_REC* p_rec = NULL;
1411 tSDP_PROTOCOL_ELEM pe;
1412 tSDP_DISC_ATTR* p_attr;
1413 uint8_t i, rec_cnt;
1414 tBTA_HL_SUP_FEATURE_LIST_ELEM sup_feature;
1415 bool sdp_parsing_ok = false, result = false;
1416 uint16_t event;
1417 tBTA_HL_MDL_CB* p_dcb;
1418 uint16_t service_uuid;
1419 uint16_t name_len;
1420
1421 #if (BTA_HL_DEBUG == TRUE)
1422 APPL_TRACE_DEBUG(
1423 "bta_hl_sdp_cback status:%d sdp_oper=%d app_idx=%d, mcl_idx=%d, "
1424 "mdl_idx=%d",
1425 status, sdp_oper, app_idx, mcl_idx, mdl_idx);
1426 #endif
1427
1428 rec_cnt = 0;
1429 service_uuid = bta_hl_get_service_uuids(sdp_oper, app_idx, mcl_idx, mdl_idx);
1430
1431 if (status == SDP_SUCCESS || status == SDP_DB_FULL) {
1432 memset(&p_cb->sdp, 0, sizeof(tBTA_HL_SDP));
1433 do {
1434 if (bta_hl_find_service_in_db(app_idx, mcl_idx, service_uuid, &p_rec)) {
1435 p_hdp_rec = &p_cb->sdp.sdp_rec[rec_cnt];
1436 p_cb->sdp.num_recs = rec_cnt + 1;
1437 } else {
1438 break;
1439 }
1440
1441 if (SDP_FindProtocolListElemInRec(p_rec, UUID_PROTOCOL_L2CAP, &pe)) {
1442 p_hdp_rec->ctrl_psm = (uint16_t)pe.params[0];
1443 } else {
1444 APPL_TRACE_WARNING("Control PSM not found");
1445 break;
1446 }
1447 if (SDP_FindAddProtoListsElemInRec(p_rec, UUID_PROTOCOL_L2CAP, &pe)) {
1448 p_hdp_rec->data_psm = (uint16_t)pe.params[0];
1449 } else {
1450 APPL_TRACE_WARNING("Data PSM not found");
1451 break;
1452 }
1453
1454 p_hdp_rec->srv_name[0] = '\0';
1455 p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_SERVICE_NAME);
1456 if (p_attr != NULL) {
1457 if (SDP_DISC_ATTR_LEN(p_attr->attr_len_type) < BT_MAX_SERVICE_NAME_LEN)
1458 name_len = (uint16_t)SDP_DISC_ATTR_LEN(p_attr->attr_len_type);
1459 else
1460 name_len = BT_MAX_SERVICE_NAME_LEN;
1461 memcpy(p_hdp_rec->srv_name, p_attr->attr_value.v.array, name_len);
1462 }
1463
1464 p_hdp_rec->srv_desp[0] = '\0';
1465 p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_SERVICE_DESCRIPTION);
1466 if (p_attr != NULL) {
1467 if (SDP_DISC_ATTR_LEN(p_attr->attr_len_type) < BT_MAX_SERVICE_NAME_LEN)
1468 name_len = (uint16_t)SDP_DISC_ATTR_LEN(p_attr->attr_len_type);
1469 else
1470 name_len = BT_MAX_SERVICE_NAME_LEN;
1471 memcpy(p_hdp_rec->srv_desp, p_attr->attr_value.v.array, name_len);
1472 }
1473
1474 p_hdp_rec->provider_name[0] = '\0';
1475 p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_PROVIDER_NAME);
1476 if (p_attr != NULL) {
1477 if (SDP_DISC_ATTR_LEN(p_attr->attr_len_type) < BT_MAX_SERVICE_NAME_LEN)
1478 name_len = (uint16_t)SDP_DISC_ATTR_LEN(p_attr->attr_len_type);
1479 else
1480 name_len = BT_MAX_SERVICE_NAME_LEN;
1481 memcpy(p_hdp_rec->provider_name, p_attr->attr_value.v.array, name_len);
1482 }
1483
1484 p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_HDP_MCAP_SUP_PROC);
1485 if (p_attr != NULL) {
1486 p_hdp_rec->mcap_sup_proc = p_attr->attr_value.v.u8;
1487 } else {
1488 APPL_TRACE_WARNING("MCAP SUP PROC not found");
1489 break;
1490 }
1491
1492 p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_HDP_SUP_FEAT_LIST);
1493 if (p_attr != NULL) {
1494 if (bta_hl_fill_sup_feature_list(p_attr, &sup_feature)) {
1495 p_hdp_rec->num_mdeps = (uint8_t)sup_feature.num_elems;
1496 APPL_TRACE_WARNING("bta_hl_sdp_cback num_mdeps %d",
1497 sup_feature.num_elems);
1498 for (i = 0; i < sup_feature.num_elems; i++) {
1499 p_hdp_rec->mdep_cfg[i].data_type =
1500 sup_feature.list_elem[i].data_type;
1501 p_hdp_rec->mdep_cfg[i].mdep_id = sup_feature.list_elem[i].mdep_id;
1502 p_hdp_rec->mdep_cfg[i].mdep_role =
1503 sup_feature.list_elem[i].mdep_role;
1504 /* Check MDEP Description pointer to prevent crash due to null
1505 * pointer */
1506 if (sup_feature.list_elem[i].p_mdep_desp != NULL) {
1507 strlcpy(p_hdp_rec->mdep_cfg[i].mdep_desp,
1508 sup_feature.list_elem[i].p_mdep_desp,
1509 BTA_HL_MDEP_DESP_LEN);
1510 } else {
1511 APPL_TRACE_ERROR(
1512 "bta_hl_sdp_cback Incorrect Mdep[%d] Description (Null ptr)",
1513 i);
1514 }
1515 }
1516
1517 sdp_parsing_ok = true;
1518 } else {
1519 APPL_TRACE_WARNING("HDP supported feature list fill failed");
1520 break;
1521 }
1522 } else {
1523 APPL_TRACE_WARNING("HDP supported feature list not found");
1524 break;
1525 }
1526 #if (BTA_HL_DEBUG == TRUE)
1527 APPL_TRACE_DEBUG("record=%d ctrl_psm=%0x data_psm=%x", rec_cnt + 1,
1528 p_hdp_rec->ctrl_psm, p_hdp_rec->data_psm);
1529 APPL_TRACE_DEBUG("srv_name=[%s]", (p_hdp_rec->srv_name[0] != '\0')
1530 ? p_hdp_rec->srv_name
1531 : "NULL");
1532 APPL_TRACE_DEBUG("srv_desp=[%s]", (p_hdp_rec->srv_desp[0] != '\0')
1533 ? p_hdp_rec->srv_desp
1534 : "NULL");
1535 for (i = 0; i < sup_feature.num_elems; i++) {
1536 APPL_TRACE_DEBUG(
1537 "index=0x%02x mdep_id=0x%04x data type=0x%04x mdep role=%s(0x%02x)",
1538 (i + 1), p_hdp_rec->mdep_cfg[i].mdep_id,
1539 p_hdp_rec->mdep_cfg[i].data_type,
1540 (p_hdp_rec->mdep_cfg[i].mdep_role == BTA_HL_MDEP_ROLE_SOURCE)
1541 ? "Src"
1542 : "Snk",
1543 p_hdp_rec->mdep_cfg[i].mdep_role);
1544 }
1545 APPL_TRACE_DEBUG("provider_name=[%s]",
1546 (p_hdp_rec->provider_name[0] != '\0')
1547 ? p_hdp_rec->provider_name
1548 : "NULL");
1549 APPL_TRACE_DEBUG("found MCAP sup procedure=%d",
1550 p_cb->sdp.sdp_rec[rec_cnt].mcap_sup_proc);
1551 #endif
1552 rec_cnt++;
1553 if (rec_cnt >= BTA_HL_NUM_SDP_RECS) {
1554 APPL_TRACE_WARNING("No more spaces for SDP recs max_rec_cnt=%d",
1555 BTA_HL_NUM_SDP_RECS);
1556 break;
1557 }
1558
1559 } while (true);
1560 }
1561
1562 osi_free_and_reset((void**)&p_cb->p_db);
1563
1564 if ((status == SDP_SUCCESS || status == SDP_DB_FULL) && p_cb->sdp.num_recs &&
1565 sdp_parsing_ok) {
1566 result = true;
1567 } else {
1568 APPL_TRACE_WARNING(
1569 "SDP Failed sdp_status=%d num_recs=%d sdp_parsing_ok=%d ", status,
1570 p_cb->sdp.num_recs, sdp_parsing_ok);
1571 }
1572
1573 p_cb->sdp_oper = BTA_HL_SDP_OP_NONE;
1574
1575 switch (sdp_oper) {
1576 case BTA_HL_SDP_OP_CCH_INIT:
1577 case BTA_HL_SDP_OP_SDP_QUERY_NEW:
1578 case BTA_HL_SDP_OP_SDP_QUERY_CURRENT:
1579
1580 /* send result in event back to BTA */
1581 p_cch_buf = (tBTA_HL_CCH_SDP*)osi_malloc(sizeof(tBTA_HL_CCH_SDP));
1582 if (result) {
1583 if (sdp_oper == BTA_HL_SDP_OP_CCH_INIT) {
1584 event = BTA_HL_CCH_SDP_OK_EVT;
1585 if (p_cb->close_pending) event = BTA_HL_CCH_SDP_FAIL_EVT;
1586 } else {
1587 event = BTA_HL_SDP_QUERY_OK_EVT;
1588 }
1589 } else {
1590 if (sdp_oper == BTA_HL_SDP_OP_CCH_INIT)
1591 event = BTA_HL_CCH_SDP_FAIL_EVT;
1592 else
1593 event = BTA_HL_SDP_QUERY_FAIL_EVT;
1594 }
1595 p_cch_buf->hdr.event = event;
1596
1597 p_cch_buf->app_idx = app_idx;
1598 p_cch_buf->mcl_idx = mcl_idx;
1599 p_cch_buf->release_mcl_cb = false;
1600 if (sdp_oper == BTA_HL_SDP_OP_SDP_QUERY_NEW)
1601 p_cch_buf->release_mcl_cb = true;
1602
1603 bta_sys_sendmsg(p_cch_buf);
1604 break;
1605 case BTA_HL_SDP_OP_DCH_OPEN_INIT:
1606 case BTA_HL_SDP_OP_DCH_RECONNECT_INIT:
1607 p_dch_buf = (tBTA_HL_DCH_SDP*)osi_malloc(sizeof(tBTA_HL_DCH_SDP));
1608 p_dch_buf->hdr.event = BTA_HL_DCH_SDP_FAIL_EVT;
1609 p_dch_buf->app_idx = app_idx;
1610 p_dch_buf->mcl_idx = mcl_idx;
1611 p_dch_buf->mdl_idx = mdl_idx;
1612 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1613 if (p_dcb->abort_oper & BTA_HL_ABORT_PENDING_MASK) {
1614 p_dcb->abort_oper &= ~BTA_HL_ABORT_PENDING_MASK;
1615 result = false;
1616 }
1617 if (result) {
1618 if (sdp_oper == BTA_HL_SDP_OP_DCH_OPEN_INIT) {
1619 if (p_dcb->local_mdep_id == BTA_HL_ECHO_TEST_MDEP_ID) {
1620 p_dch_buf->hdr.event = BTA_HL_DCH_ECHO_TEST_EVT;
1621 } else {
1622 p_dch_buf->hdr.event = BTA_HL_DCH_OPEN_EVT;
1623 }
1624 } else {
1625 p_dch_buf->hdr.event = BTA_HL_DCH_RECONNECT_EVT;
1626 }
1627 }
1628 bta_sys_sendmsg(p_dch_buf);
1629 break;
1630 default:
1631 break;
1632 }
1633 }
1634
1635 /******************************************************************************
1636 *
1637 * Function bta_hl_sdp_cback0
1638 *
1639 * Description This is the SDP callback function used by index = 0
1640 *
1641 * Returns void.
1642 *
1643 *****************************************************************************/
bta_hl_sdp_cback0(uint16_t status)1644 static void bta_hl_sdp_cback0(uint16_t status) {
1645 bta_hl_sdp_cback(bta_hl_cb.scb[0].sdp_oper, bta_hl_cb.scb[0].app_idx,
1646 bta_hl_cb.scb[0].mcl_idx, bta_hl_cb.scb[0].mdl_idx, status);
1647 bta_hl_deallocate_spd_cback(0);
1648 }
1649
1650 /******************************************************************************
1651 *
1652 * Function bta_hl_sdp_cback1
1653 *
1654 * Description This is the SDP callback function used by index = 1
1655 *
1656 * Parameters status - status of the SDP callabck
1657 *
1658 * Returns void.
1659 *
1660 *****************************************************************************/
bta_hl_sdp_cback1(uint16_t status)1661 static void bta_hl_sdp_cback1(uint16_t status) {
1662 bta_hl_sdp_cback(bta_hl_cb.scb[1].sdp_oper, bta_hl_cb.scb[1].app_idx,
1663 bta_hl_cb.scb[1].mcl_idx, bta_hl_cb.scb[1].mdl_idx, status);
1664 bta_hl_deallocate_spd_cback(1);
1665 }
1666
1667 /******************************************************************************
1668 *
1669 * Function bta_hl_sdp_cback2
1670 *
1671 * Description This is the SDP callback function used by index = 2
1672 *
1673 * Returns void.
1674 *
1675 *****************************************************************************/
bta_hl_sdp_cback2(uint16_t status)1676 static void bta_hl_sdp_cback2(uint16_t status) {
1677 bta_hl_sdp_cback(bta_hl_cb.scb[2].sdp_oper, bta_hl_cb.scb[2].app_idx,
1678 bta_hl_cb.scb[2].mcl_idx, bta_hl_cb.scb[2].mdl_idx, status);
1679 bta_hl_deallocate_spd_cback(2);
1680 }
1681
1682 /******************************************************************************
1683 *
1684 * Function bta_hl_sdp_cback3
1685 *
1686 * Description This is the SDP callback function used by index = 3
1687 *
1688 * Returns void.
1689 *
1690 *****************************************************************************/
bta_hl_sdp_cback3(uint16_t status)1691 static void bta_hl_sdp_cback3(uint16_t status) {
1692 bta_hl_sdp_cback(bta_hl_cb.scb[3].sdp_oper, bta_hl_cb.scb[3].app_idx,
1693 bta_hl_cb.scb[3].mcl_idx, bta_hl_cb.scb[3].mdl_idx, status);
1694 bta_hl_deallocate_spd_cback(3);
1695 }
1696
1697 /******************************************************************************
1698 *
1699 * Function bta_hl_sdp_cback4
1700 *
1701 * Description This is the SDP callback function used by index = 4
1702 *
1703 * Parameters status - status of the SDP callabck
1704 *
1705 * Returns void.
1706 *
1707 *****************************************************************************/
bta_hl_sdp_cback4(uint16_t status)1708 static void bta_hl_sdp_cback4(uint16_t status) {
1709 bta_hl_sdp_cback(bta_hl_cb.scb[4].sdp_oper, bta_hl_cb.scb[4].app_idx,
1710 bta_hl_cb.scb[4].mcl_idx, bta_hl_cb.scb[4].mdl_idx, status);
1711 bta_hl_deallocate_spd_cback(4);
1712 }
1713
1714 /******************************************************************************
1715 *
1716 * Function bta_hl_sdp_cback5
1717 *
1718 * Description This is the SDP callback function used by index = 5
1719 *
1720 * Parameters status - status of the SDP callabck
1721 *
1722 * Returns void.
1723 *
1724 *****************************************************************************/
bta_hl_sdp_cback5(uint16_t status)1725 static void bta_hl_sdp_cback5(uint16_t status) {
1726 bta_hl_sdp_cback(bta_hl_cb.scb[5].sdp_oper, bta_hl_cb.scb[5].app_idx,
1727 bta_hl_cb.scb[5].mcl_idx, bta_hl_cb.scb[5].mdl_idx, status);
1728 bta_hl_deallocate_spd_cback(5);
1729 }
1730
1731 /******************************************************************************
1732 *
1733 * Function bta_hl_sdp_cback6
1734 *
1735 * Description This is the SDP callback function used by index = 6
1736 *
1737 * Returns void.
1738 *
1739 *****************************************************************************/
bta_hl_sdp_cback6(uint16_t status)1740 static void bta_hl_sdp_cback6(uint16_t status) {
1741 bta_hl_sdp_cback(bta_hl_cb.scb[6].sdp_oper, bta_hl_cb.scb[6].app_idx,
1742 bta_hl_cb.scb[6].mcl_idx, bta_hl_cb.scb[6].mdl_idx, status);
1743 bta_hl_deallocate_spd_cback(6);
1744 }
1745
1746 /*******************************************************************************
1747 *
1748 * Function bta_hl_deallocate_spd_cback
1749 *
1750 * Description Deallocate a SDP control block
1751 *
1752 * Returns bool - true found
1753 * false not found
1754 *
1755 ******************************************************************************/
bta_hl_deallocate_spd_cback(uint8_t sdp_cback_idx)1756 void bta_hl_deallocate_spd_cback(uint8_t sdp_cback_idx) {
1757 tBTA_HL_SDP_CB* p_spd_cb = &bta_hl_cb.scb[sdp_cback_idx];
1758
1759 memset(p_spd_cb, 0, sizeof(tBTA_HL_SDP_CB));
1760
1761 #if (BTA_HL_DEBUG == TRUE)
1762 APPL_TRACE_DEBUG("bta_hl_deallocate_spd_cback index=%d", sdp_cback_idx);
1763 #endif
1764 }
1765
1766 /*******************************************************************************
1767 *
1768 * Function bta_hl_allocate_spd_cback
1769 *
1770 * Description Finds a not in used SDP control block index
1771 *
1772 *
1773 * Returns bool - true found
1774 * false not found
1775 *
1776 ******************************************************************************/
bta_hl_allocate_spd_cback(tBTA_HL_SDP_OPER sdp_oper,uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,uint8_t * p_sdp_cback_idx)1777 tSDP_DISC_CMPL_CB* bta_hl_allocate_spd_cback(tBTA_HL_SDP_OPER sdp_oper,
1778 uint8_t app_idx, uint8_t mcl_idx,
1779 uint8_t mdl_idx,
1780 uint8_t* p_sdp_cback_idx) {
1781 uint8_t i;
1782 tSDP_DISC_CMPL_CB* p_cbcak = NULL;
1783
1784 for (i = 0; i < BTA_HL_NUM_SDP_CBACKS; i++) {
1785 if (!bta_hl_cb.scb[i].in_use) {
1786 p_cbcak = bta_hl_sdp_cback_arr[i];
1787 bta_hl_cb.scb[i].in_use = true;
1788 bta_hl_cb.scb[i].sdp_oper = sdp_oper;
1789 bta_hl_cb.scb[i].app_idx = app_idx;
1790 bta_hl_cb.scb[i].mcl_idx = mcl_idx;
1791 bta_hl_cb.scb[i].mdl_idx = mdl_idx;
1792 *p_sdp_cback_idx = i;
1793 break;
1794 }
1795 }
1796
1797 if (i == BTA_HL_NUM_SDP_CBACKS) {
1798 APPL_TRACE_WARNING("No scb is available to allocate")
1799 } else {
1800 #if (BTA_HL_DEBUG == TRUE)
1801 APPL_TRACE_DEBUG("bta_hl_allocate_spd_cback cback_idx=%d ", i);
1802 APPL_TRACE_DEBUG("sdp_oper=%d, app_idx=%d, mcl_idx=%d, mdl_idx=%d",
1803 bta_hl_cb.scb[i].sdp_oper, bta_hl_cb.scb[i].app_idx,
1804 bta_hl_cb.scb[i].mcl_idx, bta_hl_cb.scb[i].mdl_idx);
1805 #endif
1806 }
1807 return p_cbcak;
1808 }
1809
1810 /*******************************************************************************
1811 *
1812 * Function bta_hl_init_sdp
1813 *
1814 * Description Action routine for processing the SDP initiattion request
1815 *
1816 * Returns void
1817 *
1818 ******************************************************************************/
bta_hl_init_sdp(tBTA_HL_SDP_OPER sdp_oper,uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx)1819 tBTA_HL_STATUS bta_hl_init_sdp(tBTA_HL_SDP_OPER sdp_oper, uint8_t app_idx,
1820 uint8_t mcl_idx, uint8_t mdl_idx) {
1821 tBTA_HL_MCL_CB* p_cb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1822 uint16_t attr_list[BTA_HL_NUM_SRCH_ATTR];
1823 uint16_t num_attrs = BTA_HL_NUM_SRCH_ATTR;
1824 tBTA_HL_STATUS status;
1825 uint8_t sdp_cback_idx;
1826 #if (BTA_HL_DEBUG == TRUE)
1827 APPL_TRACE_DEBUG(
1828 "bta_hl_init_sdp sdp_oper=%d app_idx=%d mcl_idx=%d, mdl_idx=%d", sdp_oper,
1829 app_idx, mcl_idx, mdl_idx);
1830 #endif
1831 p_cb->sdp_cback = bta_hl_allocate_spd_cback(sdp_oper, app_idx, mcl_idx,
1832 mdl_idx, &sdp_cback_idx);
1833 if (p_cb->sdp_cback != NULL) {
1834 if (p_cb->p_db == NULL)
1835 (p_cb->p_db = (tSDP_DISCOVERY_DB*)osi_malloc(BTA_HL_DISC_SIZE));
1836 attr_list[0] = ATTR_ID_SERVICE_CLASS_ID_LIST;
1837 attr_list[1] = ATTR_ID_PROTOCOL_DESC_LIST;
1838 attr_list[2] = ATTR_ID_BT_PROFILE_DESC_LIST;
1839 attr_list[3] = ATTR_ID_ADDITION_PROTO_DESC_LISTS;
1840 attr_list[4] = ATTR_ID_SERVICE_NAME;
1841 attr_list[5] = ATTR_ID_SERVICE_DESCRIPTION;
1842 attr_list[6] = ATTR_ID_PROVIDER_NAME;
1843 attr_list[7] = ATTR_ID_HDP_SUP_FEAT_LIST;
1844 attr_list[8] = ATTR_ID_HDP_DATA_EXCH_SPEC;
1845 attr_list[9] = ATTR_ID_HDP_MCAP_SUP_PROC;
1846
1847 Uuid uuid_list = Uuid::From16Bit(UUID_SERVCLASS_HDP_PROFILE);
1848 SDP_InitDiscoveryDb(p_cb->p_db, BTA_HL_DISC_SIZE, 1, &uuid_list, num_attrs,
1849 attr_list);
1850
1851 if (!SDP_ServiceSearchAttributeRequest(p_cb->bd_addr, p_cb->p_db,
1852 p_cb->sdp_cback)) {
1853 status = BTA_HL_STATUS_FAIL;
1854 } else {
1855 status = BTA_HL_STATUS_OK;
1856 }
1857 } else {
1858 status = BTA_HL_STATUS_SDP_NO_RESOURCE;
1859 }
1860
1861 if (status != BTA_HL_STATUS_OK) {
1862 osi_free_and_reset((void**)&p_cb->p_db);
1863 if (status != BTA_HL_STATUS_SDP_NO_RESOURCE)
1864 bta_hl_deallocate_spd_cback(sdp_cback_idx);
1865 }
1866
1867 return status;
1868 }
1869
1870 /*******************************************************************************
1871 *
1872 * Function bta_hl_cch_sdp_init
1873 *
1874 * Description Action routine for processing the CCH SDP init event
1875 *
1876 * Returns void
1877 *
1878 ******************************************************************************/
bta_hl_cch_sdp_init(uint8_t app_idx,uint8_t mcl_idx,tBTA_HL_DATA * p_data)1879 void bta_hl_cch_sdp_init(uint8_t app_idx, uint8_t mcl_idx,
1880 tBTA_HL_DATA* p_data) {
1881 tBTA_HL_MCL_CB* p_cb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1882 #if (BTA_HL_DEBUG == TRUE)
1883 APPL_TRACE_DEBUG("bta_hl_cch_init_sdp");
1884 #endif
1885 if (p_cb->sdp_oper == BTA_HL_SDP_OP_NONE) {
1886 p_cb->app_id = p_data->api_cch_open.app_id;
1887 p_cb->sdp_oper = BTA_HL_SDP_OP_CCH_INIT;
1888
1889 if (bta_hl_init_sdp(p_cb->sdp_oper, app_idx, mcl_idx, 0xFF) !=
1890 BTA_HL_STATUS_OK) {
1891 p_cb->sdp_oper = BTA_HL_SDP_OP_NONE;
1892 bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_SDP_FAIL_EVT, p_data);
1893 }
1894 } else {
1895 APPL_TRACE_ERROR("SDP in use");
1896 bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_SDP_FAIL_EVT, p_data);
1897 }
1898 }
1899
1900 /*******************************************************************************
1901 *
1902 * Function bta_hl_cch_mca_open
1903 *
1904 * Description Action routine for processing the CCH open request
1905 *
1906 * Returns void
1907 *
1908 ******************************************************************************/
bta_hl_cch_mca_open(uint8_t app_idx,uint8_t mcl_idx,tBTA_HL_DATA * p_data)1909 void bta_hl_cch_mca_open(uint8_t app_idx, uint8_t mcl_idx,
1910 tBTA_HL_DATA* p_data) {
1911 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1912 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1913 uint8_t sdp_idx;
1914
1915 #if (BTA_HL_DEBUG == TRUE)
1916 APPL_TRACE_DEBUG("bta_hl_cch_mca_open");
1917 #endif
1918
1919 if (bta_hl_find_sdp_idx_using_ctrl_psm(&p_mcb->sdp, p_mcb->req_ctrl_psm,
1920 &sdp_idx)) {
1921 p_mcb->ctrl_psm = p_mcb->sdp.sdp_rec[sdp_idx].ctrl_psm;
1922 p_mcb->data_psm = p_mcb->sdp.sdp_rec[sdp_idx].data_psm;
1923 if (MCA_ConnectReq((tMCA_HANDLE)p_acb->app_handle, p_mcb->bd_addr,
1924 p_mcb->ctrl_psm, p_mcb->sec_mask) != MCA_SUCCESS) {
1925 bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_CLOSE_CMPL_EVT,
1926 p_data);
1927 }
1928 } else {
1929 bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_CLOSE_CMPL_EVT, p_data);
1930 }
1931 }
1932
1933 /*******************************************************************************
1934 *
1935 * Function bta_hl_cch_mca_close
1936 *
1937 * Description Action routine for processing the CCH close request
1938 *
1939 * Returns void
1940 *
1941 ******************************************************************************/
bta_hl_cch_mca_close(uint8_t app_idx,uint8_t mcl_idx,tBTA_HL_DATA * p_data)1942 void bta_hl_cch_mca_close(uint8_t app_idx, uint8_t mcl_idx,
1943 tBTA_HL_DATA* p_data) {
1944 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1945
1946 #if (BTA_HL_DEBUG == TRUE)
1947 APPL_TRACE_DEBUG("bta_hl_cch_mca_close mcl_handle=%d", p_mcb->mcl_handle);
1948 #endif
1949 if (p_mcb->sdp_oper != BTA_HL_SDP_OP_CCH_INIT) {
1950 if (p_mcb->mcl_handle) {
1951 if (MCA_DisconnectReq((tMCA_HANDLE)p_mcb->mcl_handle) != MCA_SUCCESS) {
1952 bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_CLOSE_CMPL_EVT,
1953 p_data);
1954 }
1955 } else {
1956 p_mcb->close_pending = true;
1957 APPL_TRACE_DEBUG(
1958 "No valid mcl_handle to stop the CCH setup now so wait until CCH is "
1959 "up then close it");
1960 }
1961 } else {
1962 p_mcb->close_pending = true;
1963 APPL_TRACE_DEBUG(
1964 "can not stop the CCH setup becasue SDP is in progress so wait until "
1965 "it is done");
1966 }
1967 }
1968
1969 /*******************************************************************************
1970 *
1971 * Function bta_hl_cch_close_cmpl
1972 *
1973 * Description Action routine for processing the CCH close complete event
1974 *
1975 * Returns void
1976 *
1977 ******************************************************************************/
bta_hl_cch_close_cmpl(uint8_t app_idx,uint8_t mcl_idx,tBTA_HL_DATA * p_data)1978 void bta_hl_cch_close_cmpl(uint8_t app_idx, uint8_t mcl_idx,
1979 tBTA_HL_DATA* p_data) {
1980 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1981 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1982
1983 tBTA_HL evt_data;
1984 tBTA_HL_EVT event;
1985 bool send_evt = true;
1986 #if (BTA_HL_DEBUG == TRUE)
1987 APPL_TRACE_DEBUG("bta_hl_cch_close_cmpl");
1988 #endif
1989 bta_sys_conn_close(BTA_ID_HL, p_acb->app_id, p_mcb->bd_addr);
1990
1991 if (p_mcb->cch_oper == BTA_HL_CCH_OP_LOCAL_CLOSE &&
1992 p_mcb->force_close_local_cch_opening) {
1993 p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_OPEN;
1994 APPL_TRACE_DEBUG(
1995 "change cch_oper from BTA_HL_CCH_OP_LOCAL_CLOSE to "
1996 "BTA_HL_CCH_OP_LOCAL_OPEN");
1997 }
1998
1999 switch (p_mcb->cch_oper) {
2000 case BTA_HL_CCH_OP_LOCAL_OPEN:
2001 bta_hl_build_cch_open_cfm(&evt_data, p_mcb->app_id, p_acb->app_handle,
2002 p_mcb->mcl_handle, p_mcb->bd_addr,
2003 BTA_HL_STATUS_FAIL);
2004 event = BTA_HL_CCH_OPEN_CFM_EVT;
2005 break;
2006 case BTA_HL_CCH_OP_LOCAL_CLOSE:
2007 bta_hl_build_cch_close_cfm(&evt_data, p_acb->app_handle,
2008 p_mcb->mcl_handle, BTA_HL_STATUS_OK);
2009 event = BTA_HL_CCH_CLOSE_CFM_EVT;
2010 break;
2011 case BTA_HL_CCH_OP_REMOTE_CLOSE:
2012 bta_hl_build_cch_close_ind(&evt_data, p_acb->app_handle,
2013 p_mcb->mcl_handle, p_mcb->intentional_close);
2014 event = BTA_HL_CCH_CLOSE_IND_EVT;
2015 break;
2016 default:
2017 send_evt = false;
2018 break;
2019 }
2020
2021 memset(p_mcb, 0, sizeof(tBTA_HL_MCL_CB));
2022
2023 if (send_evt) p_acb->p_cback(event, (tBTA_HL*)&evt_data);
2024
2025 bta_hl_check_deregistration(app_idx, p_data);
2026 }
2027
2028 /*******************************************************************************
2029 *
2030 * Function bta_hl_cch_mca_disconnect
2031 *
2032 * Description Action routine for processing the CCH disconnect indication
2033 *
2034 * Returns void
2035 *
2036 ******************************************************************************/
bta_hl_cch_mca_disconnect(uint8_t app_idx,uint8_t mcl_idx,tBTA_HL_DATA * p_data)2037 void bta_hl_cch_mca_disconnect(uint8_t app_idx, uint8_t mcl_idx,
2038 tBTA_HL_DATA* p_data) {
2039 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2040 tBTA_HL_MDL_CB* p_dcb;
2041 uint8_t i;
2042 #if (BTA_HL_DEBUG == TRUE)
2043 APPL_TRACE_DEBUG("bta_hl_cch_mca_disconnect");
2044 #endif
2045
2046 p_mcb->intentional_close = false;
2047 if (p_data->mca_evt.mca_data.disconnect_ind.reason == L2CAP_DISC_OK) {
2048 p_mcb->intentional_close = true;
2049 }
2050
2051 for (i = 0; i < BTA_HL_NUM_MDLS_PER_MCL; i++) {
2052 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, i);
2053 if (p_dcb->in_use && (p_dcb->dch_state != BTA_HL_DCH_IDLE_ST)) {
2054 if (p_mcb->cch_oper == BTA_HL_CCH_OP_LOCAL_CLOSE) {
2055 bta_hl_dch_sm_execute(app_idx, mcl_idx, i, BTA_HL_DCH_CLOSE_CMPL_EVT,
2056 p_data);
2057 } else {
2058 bta_hl_dch_sm_execute(app_idx, mcl_idx, i, BTA_HL_MCA_CLOSE_IND_EVT,
2059 p_data);
2060 }
2061 }
2062 }
2063 bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_CLOSE_CMPL_EVT, p_data);
2064 }
2065
2066 /*******************************************************************************
2067 *
2068 * Function bta_hl_cch_mca_disc_open
2069 *
2070 * Description Action routine for disconnect the just opened Control
2071 * channel
2072 *
2073 * Returns void
2074 *
2075 ******************************************************************************/
bta_hl_cch_mca_disc_open(uint8_t app_idx,uint8_t mcl_idx,tBTA_HL_DATA * p_data)2076 void bta_hl_cch_mca_disc_open(uint8_t app_idx, uint8_t mcl_idx,
2077 tBTA_HL_DATA* p_data) {
2078 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2079
2080 #if (BTA_HL_DEBUG == TRUE)
2081 APPL_TRACE_DEBUG("bta_hl_cch_mca_disc_open mcl_handle=0x%x close_pending=%d",
2082 p_data->mca_evt.mcl_handle, p_mcb->close_pending);
2083 #endif
2084
2085 p_mcb->close_pending = false;
2086 p_mcb->mcl_handle = p_data->mca_evt.mcl_handle;
2087 bta_hl_cch_mca_close(app_idx, mcl_idx, p_data);
2088 }
2089
2090 /*******************************************************************************
2091 *
2092 * Function bta_hl_cch_mca_rsp_tout
2093 *
2094 * Description Action routine for processing the MCAP response timeout
2095 *
2096 * Returns void
2097 *
2098 ******************************************************************************/
bta_hl_cch_mca_rsp_tout(uint8_t app_idx,uint8_t mcl_idx,tBTA_HL_DATA * p_data)2099 void bta_hl_cch_mca_rsp_tout(uint8_t app_idx, uint8_t mcl_idx,
2100 tBTA_HL_DATA* p_data) {
2101 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2102 #if (BTA_HL_DEBUG == TRUE)
2103 APPL_TRACE_DEBUG("bta_hl_cch_mca_rsp_tout");
2104 #endif
2105
2106 p_mcb->rsp_tout = true;
2107
2108 bta_hl_check_cch_close(app_idx, mcl_idx, p_data, true);
2109 }
2110
2111 /*******************************************************************************
2112 *
2113 * Function bta_hl_cch_mca_connect
2114 *
2115 * Description Action routine for processing the CCH connect indication
2116 *
2117 * Returns void
2118 *
2119 ******************************************************************************/
bta_hl_cch_mca_connect(uint8_t app_idx,uint8_t mcl_idx,tBTA_HL_DATA * p_data)2120 void bta_hl_cch_mca_connect(uint8_t app_idx, uint8_t mcl_idx,
2121 tBTA_HL_DATA* p_data) {
2122 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
2123 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
2124 tBTA_HL evt_data;
2125 tBTA_HL_EVT event;
2126 bool send_event = true;
2127
2128 #if (BTA_HL_DEBUG == TRUE)
2129 APPL_TRACE_DEBUG("bta_hl_cch_mca_connect mcl_handle=%d ",
2130 p_data->mca_evt.mcl_handle);
2131 #endif
2132
2133 p_mcb->mcl_handle = p_data->mca_evt.mcl_handle;
2134 p_mcb->bd_addr = p_data->mca_evt.mca_data.connect_ind.bd_addr;
2135 p_mcb->cch_mtu = p_data->mca_evt.mca_data.connect_ind.mtu;
2136
2137 bta_sys_conn_open(BTA_ID_HL, p_acb->app_id, p_mcb->bd_addr);
2138 switch (p_mcb->cch_oper) {
2139 case BTA_HL_CCH_OP_LOCAL_OPEN:
2140 bta_hl_build_cch_open_cfm(&evt_data, p_mcb->app_id, p_acb->app_handle,
2141 p_mcb->mcl_handle, p_mcb->bd_addr,
2142 BTA_HL_STATUS_OK);
2143 event = BTA_HL_CCH_OPEN_CFM_EVT;
2144 break;
2145 case BTA_HL_CCH_OP_REMOTE_OPEN:
2146 bta_hl_build_cch_open_ind(&evt_data, p_acb->app_handle, p_mcb->mcl_handle,
2147 p_mcb->bd_addr);
2148 event = BTA_HL_CCH_OPEN_IND_EVT;
2149 break;
2150 default:
2151 send_event = false;
2152 break;
2153 }
2154
2155 p_mcb->cch_oper = BTA_HL_CCH_OP_NONE;
2156 if (send_event) p_acb->p_cback(event, (tBTA_HL*)&evt_data);
2157 }
2158
2159 /*******************************************************************************
2160 *
2161 * Function bta_hl_mcap_ctrl_cback
2162 *
2163 * Description MCAP control callback function for HL.
2164 *
2165 * Returns void
2166 *
2167 ******************************************************************************/
bta_hl_mcap_ctrl_cback(tMCA_HANDLE handle,tMCA_CL mcl,uint8_t event,tMCA_CTRL * p_data)2168 void bta_hl_mcap_ctrl_cback(tMCA_HANDLE handle, tMCA_CL mcl, uint8_t event,
2169 tMCA_CTRL* p_data) {
2170 bool send_event = true;
2171 uint16_t mca_event;
2172
2173 #if (BTA_HL_DEBUG == TRUE)
2174 APPL_TRACE_EVENT("bta_hl_mcap_ctrl_cback event[%s]",
2175 bta_hl_mcap_evt_code(event));
2176 #endif
2177
2178 switch (event) {
2179 case MCA_CREATE_IND_EVT:
2180 mca_event = (uint16_t)BTA_HL_MCA_CREATE_IND_EVT;
2181 break;
2182 case MCA_CREATE_CFM_EVT:
2183 mca_event = (uint16_t)BTA_HL_MCA_CREATE_CFM_EVT;
2184 break;
2185 case MCA_RECONNECT_IND_EVT:
2186 mca_event = (uint16_t)BTA_HL_MCA_RECONNECT_IND_EVT;
2187 break;
2188 case MCA_RECONNECT_CFM_EVT:
2189 mca_event = (uint16_t)BTA_HL_MCA_RECONNECT_CFM_EVT;
2190 break;
2191 case MCA_ABORT_IND_EVT:
2192 mca_event = (uint16_t)BTA_HL_MCA_ABORT_IND_EVT;
2193 break;
2194 case MCA_ABORT_CFM_EVT:
2195 mca_event = (uint16_t)BTA_HL_MCA_ABORT_CFM_EVT;
2196 break;
2197 case MCA_DELETE_IND_EVT:
2198 mca_event = (uint16_t)BTA_HL_MCA_DELETE_IND_EVT;
2199 break;
2200 case MCA_DELETE_CFM_EVT:
2201 mca_event = (uint16_t)BTA_HL_MCA_DELETE_CFM_EVT;
2202 break;
2203 case MCA_CONNECT_IND_EVT:
2204 mca_event = (uint16_t)BTA_HL_MCA_CONNECT_IND_EVT;
2205 break;
2206 case MCA_DISCONNECT_IND_EVT:
2207 mca_event = (uint16_t)BTA_HL_MCA_DISCONNECT_IND_EVT;
2208 break;
2209 case MCA_OPEN_IND_EVT:
2210 mca_event = (uint16_t)BTA_HL_MCA_OPEN_IND_EVT;
2211 break;
2212 case MCA_OPEN_CFM_EVT:
2213 mca_event = (uint16_t)BTA_HL_MCA_OPEN_CFM_EVT;
2214 break;
2215 case MCA_CLOSE_IND_EVT:
2216 mca_event = (uint16_t)BTA_HL_MCA_CLOSE_IND_EVT;
2217 break;
2218 case MCA_CLOSE_CFM_EVT:
2219 mca_event = (uint16_t)BTA_HL_MCA_CLOSE_CFM_EVT;
2220 break;
2221 case MCA_CONG_CHG_EVT:
2222 mca_event = (uint16_t)BTA_HL_MCA_CONG_CHG_EVT;
2223 break;
2224 case MCA_RSP_TOUT_IND_EVT:
2225 mca_event = (uint16_t)BTA_HL_MCA_RSP_TOUT_IND_EVT;
2226 break;
2227 case MCA_ERROR_RSP_EVT:
2228
2229 default:
2230 send_event = false;
2231 break;
2232 }
2233
2234 if (send_event) {
2235 tBTA_HL_MCA_EVT* p_msg =
2236 (tBTA_HL_MCA_EVT*)osi_malloc(sizeof(tBTA_HL_MCA_EVT));
2237 p_msg->hdr.event = mca_event;
2238 p_msg->app_handle = (tBTA_HL_APP_HANDLE)handle;
2239 p_msg->mcl_handle = (tBTA_HL_MCL_HANDLE)mcl;
2240 memcpy(&p_msg->mca_data, p_data, sizeof(tMCA_CTRL));
2241 bta_sys_sendmsg(p_msg);
2242 }
2243 }
2244
2245 /*******************************************************************************
2246 *
2247 * Function bta_hl_mcap_data_cback
2248 *
2249 * Description MCAP data callback function for HL.
2250 *
2251 * Returns void
2252 *
2253 ******************************************************************************/
bta_hl_mcap_data_cback(tMCA_DL mdl,BT_HDR * p_pkt)2254 void bta_hl_mcap_data_cback(tMCA_DL mdl, BT_HDR* p_pkt) {
2255 uint8_t app_idx, mcl_idx, mdl_idx;
2256 if (bta_hl_find_mdl_idx_using_handle((tBTA_HL_MDL_HANDLE)mdl, &app_idx,
2257 &mcl_idx, &mdl_idx)) {
2258 tBTA_HL_MCA_RCV_DATA_EVT* p_msg =
2259 (tBTA_HL_MCA_RCV_DATA_EVT*)osi_malloc(sizeof(tBTA_HL_MCA_RCV_DATA_EVT));
2260 p_msg->hdr.event = BTA_HL_MCA_RCV_DATA_EVT;
2261 p_msg->app_idx = app_idx;
2262 p_msg->mcl_idx = mcl_idx;
2263 p_msg->mdl_idx = mdl_idx;
2264 p_msg->p_pkt = p_pkt;
2265 bta_sys_sendmsg(p_msg);
2266 }
2267 }
2268
2269 /*****************************************************************************
2270 * Debug Functions
2271 ****************************************************************************/
2272 #if (BTA_HL_DEBUG == TRUE)
2273
2274 #define CASE_RETURN_STR(const) \
2275 case const: \
2276 return #const;
2277
2278 /*******************************************************************************
2279 *
2280 * Function bta_hl_mcap_evt_code
2281 *
2282 * Description get the MCAP event string pointer
2283 *
2284 * Returns char * - event string pointer
2285 *
2286 ******************************************************************************/
bta_hl_mcap_evt_code(uint8_t evt_code)2287 static const char* bta_hl_mcap_evt_code(uint8_t evt_code) {
2288 switch (evt_code) {
2289 CASE_RETURN_STR(MCA_ERROR_RSP_EVT)
2290 CASE_RETURN_STR(MCA_CREATE_IND_EVT)
2291 CASE_RETURN_STR(MCA_CREATE_CFM_EVT)
2292 CASE_RETURN_STR(MCA_RECONNECT_IND_EVT)
2293 CASE_RETURN_STR(MCA_RECONNECT_CFM_EVT)
2294 CASE_RETURN_STR(MCA_ABORT_IND_EVT)
2295 CASE_RETURN_STR(MCA_ABORT_CFM_EVT)
2296 CASE_RETURN_STR(MCA_DELETE_IND_EVT)
2297 CASE_RETURN_STR(MCA_DELETE_CFM_EVT)
2298 CASE_RETURN_STR(MCA_CONNECT_IND_EVT)
2299 CASE_RETURN_STR(MCA_DISCONNECT_IND_EVT)
2300 CASE_RETURN_STR(MCA_OPEN_IND_EVT)
2301 CASE_RETURN_STR(MCA_OPEN_CFM_EVT)
2302 CASE_RETURN_STR(MCA_CLOSE_IND_EVT)
2303 CASE_RETURN_STR(MCA_CLOSE_CFM_EVT)
2304 CASE_RETURN_STR(MCA_CONG_CHG_EVT)
2305 CASE_RETURN_STR(MCA_RSP_TOUT_IND_EVT)
2306 default:
2307 return "Unknown MCAP event code";
2308 }
2309 }
2310
2311 /*******************************************************************************
2312 *
2313 * Function bta_hl_cback_evt_code
2314 *
2315 * Description get the HDP event string pointer
2316 *
2317 * Returns char * - event string pointer
2318 *
2319 ******************************************************************************/
bta_hl_cback_evt_code(uint8_t evt_code)2320 static const char* bta_hl_cback_evt_code(uint8_t evt_code) {
2321 switch (evt_code) {
2322 CASE_RETURN_STR(BTA_HL_CCH_OPEN_IND_EVT)
2323 CASE_RETURN_STR(BTA_HL_CCH_OPEN_CFM_EVT)
2324 CASE_RETURN_STR(BTA_HL_CCH_CLOSE_IND_EVT)
2325 CASE_RETURN_STR(BTA_HL_CCH_CLOSE_CFM_EVT)
2326 CASE_RETURN_STR(BTA_HL_DCH_OPEN_IND_EVT)
2327 CASE_RETURN_STR(BTA_HL_DCH_OPEN_CFM_EVT)
2328 CASE_RETURN_STR(BTA_HL_DCH_CLOSE_IND_EVT)
2329 CASE_RETURN_STR(BTA_HL_DCH_CLOSE_CFM_EVT)
2330 CASE_RETURN_STR(BTA_HL_DCH_RCV_DATA_IND_EVT)
2331 CASE_RETURN_STR(BTA_HL_REGISTER_CFM_EVT)
2332 CASE_RETURN_STR(BTA_HL_DEREGISTER_CFM_EVT)
2333 CASE_RETURN_STR(BTA_HL_DCH_RECONNECT_CFM_EVT)
2334 CASE_RETURN_STR(BTA_HL_DCH_RECONNECT_IND_EVT)
2335 CASE_RETURN_STR(BTA_HL_DCH_ECHO_TEST_CFM_EVT)
2336 CASE_RETURN_STR(BTA_HL_SDP_QUERY_CFM_EVT)
2337 CASE_RETURN_STR(BTA_HL_CONG_CHG_IND_EVT)
2338 CASE_RETURN_STR(BTA_HL_DCH_CREATE_IND_EVT)
2339 CASE_RETURN_STR(BTA_HL_DELETE_MDL_IND_EVT)
2340 CASE_RETURN_STR(BTA_HL_DELETE_MDL_CFM_EVT)
2341 CASE_RETURN_STR(BTA_HL_DCH_ABORT_IND_EVT)
2342 CASE_RETURN_STR(BTA_HL_DCH_ABORT_CFM_EVT)
2343 default:
2344 return "Unknown HDP event code";
2345 }
2346 }
2347
2348 /*******************************************************************************
2349 *
2350 * Function bta_hl_dch_oper_code
2351 *
2352 * Description Get the DCH operation string
2353 *
2354 * Returns char * - DCH operation string pointer
2355 *
2356 ******************************************************************************/
bta_hl_dch_oper_code(tBTA_HL_DCH_OPER oper_code)2357 static const char* bta_hl_dch_oper_code(tBTA_HL_DCH_OPER oper_code) {
2358 switch (oper_code) {
2359 CASE_RETURN_STR(BTA_HL_DCH_OP_NONE)
2360 CASE_RETURN_STR(BTA_HL_DCH_OP_REMOTE_CREATE)
2361 CASE_RETURN_STR(BTA_HL_DCH_OP_LOCAL_OPEN)
2362 CASE_RETURN_STR(BTA_HL_DCH_OP_REMOTE_OPEN)
2363 CASE_RETURN_STR(BTA_HL_DCH_OP_LOCAL_CLOSE)
2364 CASE_RETURN_STR(BTA_HL_DCH_OP_REMOTE_CLOSE)
2365 CASE_RETURN_STR(BTA_HL_DCH_OP_LOCAL_DELETE)
2366 CASE_RETURN_STR(BTA_HL_DCH_OP_REMOTE_DELETE)
2367 CASE_RETURN_STR(BTA_HL_DCH_OP_LOCAL_RECONNECT)
2368 CASE_RETURN_STR(BTA_HL_DCH_OP_REMOTE_RECONNECT)
2369 CASE_RETURN_STR(BTA_HL_DCH_OP_LOCAL_CLOSE_ECHO_TEST)
2370 CASE_RETURN_STR(BTA_HL_DCH_OP_LOCAL_CLOSE_RECONNECT)
2371 default:
2372 return "Unknown DCH oper code";
2373 }
2374 }
2375
2376 #endif /* Debug Functions */
2377 #endif /* HL_INCLUDED */
2378