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