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