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 <sys/prctl.h> 45#include <cutils/sockets.h> 46#include <cutils/log.h> 47 48#include <hardware/bluetooth.h> 49#include <hardware/bt_hl.h> 50 51#include "btif_common.h" 52#include "btif_util.h" 53#include "gki.h" 54#include "bd.h" 55#include "bta_api.h" 56#include "bta_hl_api.h" 57#include "mca_api.h" 58#include "btif_hl.h" 59#include "btif_storage.h" 60#include "btu.h" 61 62#define MAX_DATATYPE_SUPPORTED 8 63 64extern int btif_hl_update_maxfd( int max_org_s); 65extern void btif_hl_select_monitor_callback( fd_set *p_cur_set, fd_set *p_org_set ); 66extern void btif_hl_select_wakeup_callback( fd_set *p_org_set , int wakeup_signal ); 67extern int btif_hl_update_maxfd( int max_org_s); 68extern void btif_hl_select_monitor_callback( fd_set *p_cur_set, fd_set *p_org_set ); 69extern void btif_hl_select_wakeup_callback( fd_set *p_org_set , int wakeup_signal ); 70extern void btif_hl_soc_thread_init(void); 71extern void btif_hl_release_mcl_sockets(UINT8 app_idx, UINT8 mcl_idx); 72extern BOOLEAN btif_hl_create_socket(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx); 73extern void btif_hl_release_socket(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx); 74 75btif_hl_cb_t btif_hl_cb; 76btif_hl_cb_t *p_btif_hl_cb = &btif_hl_cb; 77 78/************************************************************************************ 79** Static variables 80************************************************************************************/ 81static bthl_callbacks_t bt_hl_callbacks_cb; 82static bthl_callbacks_t *bt_hl_callbacks=NULL; 83 84/* signal socketpair to wake up select loop */ 85 86const int btif_hl_signal_select_wakeup = 1; 87const int btif_hl_signal_select_exit = 2; 88const int btif_hl_signal_select_close_connected = 3; 89 90static int listen_s = -1; 91static int connected_s = -1; 92static int select_thread_id = -1; 93static int signal_fds[2] = { -1, -1 }; 94static BUFFER_Q soc_queue; 95static int reg_counter; 96 97static inline int btif_hl_select_wakeup(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_WARNING("BTHL: %s: BTHL not initialized", __FUNCTION__);\ 135 return BT_STATUS_NOT_READY;\ 136 }\ 137 else\ 138 {\ 139 BTIF_TRACE_EVENT("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_DEBUG("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_DEBUG("%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_DEBUG("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_DEBUG("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_DEBUG("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_DEBUG("btif_hl_num_dchs_in_use:found x =%d",x); 257 cnt++; 258 } 259 } 260 } 261 } 262 } 263 } 264 265 BTIF_TRACE_DEBUG("%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_DEBUG("%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_DEBUG("%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_DEBUG("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_DEBUG("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_DEBUG("%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_DEBUG("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_DEBUG("%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_DEBUG("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_DEBUG("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_DEBUG("%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_DEBUG("%s", __FUNCTION__); 409 BTIF_TRACE_DEBUG("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_DEBUG("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_DEBUG("%s OK", __FUNCTION__ ); 437 GKI_freebuf(*p); 438 *p = NULL; 439 } 440 else 441 BTIF_TRACE_ERROR("%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_DEBUG("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_DEBUG("%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_DEBUG("%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_DEBUG("%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_DEBUG("%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_DEBUG("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_DEBUG("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_DEBUG("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_DEBUG("%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_DEBUG("%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_ERROR("Invalid local_cfg=%d",local_cfg ); 683 return is_reconnect_ok; 684 break; 685 686 } 687 688 BTIF_TRACE_DEBUG("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_DEBUG("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_DEBUG("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_DEBUG("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_DEBUG("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_DEBUG("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_DEBUG("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_DEBUG("%s app_id=%d ", 776 __FUNCTION__, app_id ); 777 BTIF_TRACE_DEBUG("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_DEBUG("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_DEBUG("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_DEBUG("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_DEBUG("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_DEBUG("%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_DEBUG("%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_DEBUG("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_ERROR("Open CCH request discarded- No mcl cb"); 964 } 965 } 966 else 967 { 968 status = FALSE; 969 BTIF_TRACE_ERROR("Open CCH request discarded- already in USE"); 970 } 971 } 972 else 973 { 974 status = FALSE; 975 BTIF_TRACE_ERROR("Invalid app_id=%d", app_id); 976 } 977 978 if (channel_id) 979 { 980 BTIF_TRACE_DEBUG("status=%d channel_id=0x%08x", status, *channel_id); 981 } 982 else 983 { 984 BTIF_TRACE_DEBUG("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_EVENT("%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_DEBUG("%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_EVENT("%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_EVENT("%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_DEBUG("%s app_id=%d local_mdep_role=%d, data_type=%d", 1188 __FUNCTION__, app_id, local_mdep_role, data_type); 1189 1190 BTIF_TRACE_DEBUG("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_DEBUG("local_mdep_role=%d", local_mdep_role); 1197 BTIF_TRACE_DEBUG("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_DEBUG("app_idx=%d mcl_idx=%d",app_idx, mcl_idx); 1212 BTIF_TRACE_DEBUG("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_DEBUG("num_mdeps=%d", num_mdeps); 1218 1219 for (i=0; i< num_mdeps; i++) 1220 { 1221 BTIF_TRACE_DEBUG("p_rec->mdep_cfg[%d].mdep_role=%d",i, p_rec->mdep_cfg[i].mdep_role); 1222 BTIF_TRACE_DEBUG("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_DEBUG("found =%d *p_peer_mdep_id=%d", found, *p_peer_mdep_id); 1236 1237 return found; 1238} 1239 1240/******************************************************************************* 1241** 1242** Function btif_hl_find_mdep_cfg_idx 1243** 1244** Description Find the MDEP configuration index using local MDEP_ID 1245** 1246** Returns BOOLEAN 1247** 1248*******************************************************************************/ 1249static BOOLEAN btif_hl_find_mdep_cfg_idx(UINT8 app_idx, tBTA_HL_MDEP_ID local_mdep_id, 1250 UINT8 *p_mdep_cfg_idx){ 1251 btif_hl_app_cb_t *p_acb =BTIF_HL_GET_APP_CB_PTR(app_idx); 1252 tBTA_HL_SUP_FEATURE *p_sup_feature= &p_acb->sup_feature; 1253 BOOLEAN found =FALSE; 1254 UINT8 i; 1255 1256 for (i=0; i< p_sup_feature->num_of_mdeps; i++) 1257 { 1258 BTIF_TRACE_DEBUG("btif_hl_find_mdep_cfg_idx: mdep_id=%d app_idx = %d", 1259 p_sup_feature->mdep[i].mdep_id,app_idx); 1260 if ( p_sup_feature->mdep[i].mdep_id == local_mdep_id) 1261 { 1262 found = TRUE; 1263 *p_mdep_cfg_idx = i; 1264 break; 1265 } 1266 } 1267 1268 BTIF_TRACE_DEBUG("%s found=%d mdep_idx=%d local_mdep_id=%d app_idx=%d ", 1269 __FUNCTION__, found,i, local_mdep_id,app_idx); 1270 return found; 1271} 1272 1273 1274 1275/******************************************************************************* 1276** 1277** Function btif_hl_find_mcl_idx 1278** 1279** Description Find the MCL index using BD address 1280** 1281** Returns BOOLEAN 1282** 1283*******************************************************************************/ 1284BOOLEAN btif_hl_find_mcl_idx(UINT8 app_idx, BD_ADDR p_bd_addr, UINT8 *p_mcl_idx){ 1285 BOOLEAN found=FALSE; 1286 UINT8 i; 1287 btif_hl_app_cb_t *p_acb =BTIF_HL_GET_APP_CB_PTR(app_idx); 1288 btif_hl_mcl_cb_t *p_mcb; 1289 1290 *p_mcl_idx = 0; 1291 for (i=0; i < BTA_HL_NUM_MCLS ; i ++) 1292 { 1293 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, i); 1294 if (p_mcb->in_use && 1295 (!memcmp (p_mcb->bd_addr, p_bd_addr, BD_ADDR_LEN))) 1296 { 1297 found = TRUE; 1298 *p_mcl_idx = i; 1299 break; 1300 } 1301 } 1302 1303 1304 BTIF_TRACE_DEBUG("%s found=%d idx=%d",__FUNCTION__, found, i); 1305 return found; 1306} 1307/******************************************************************************* 1308** 1309** Function btif_hl_init 1310** 1311** Description HL initialization function. 1312** 1313** Returns void 1314** 1315*******************************************************************************/ 1316static void btif_hl_init(void){ 1317 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 1318 memset(p_btif_hl_cb, 0, sizeof(btif_hl_cb_t)); 1319 btif_hl_init_next_app_id(); 1320 btif_hl_init_next_channel_id(); 1321} 1322/******************************************************************************* 1323** 1324** Function btif_hl_disable 1325** 1326** Description Disable initialization function. 1327** 1328** Returns void 1329** 1330*******************************************************************************/ 1331static void btif_hl_disable(void){ 1332 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 1333 1334 if ((p_btif_hl_cb->state != BTIF_HL_STATE_DISABLING) && 1335 (p_btif_hl_cb->state != BTIF_HL_STATE_DISABLED)) 1336 { 1337 btif_hl_set_state(BTIF_HL_STATE_DISABLING); 1338 BTA_HlDisable(); 1339 } 1340} 1341/******************************************************************************* 1342** 1343** Function btif_hl_is_no_active_app 1344** 1345** Description Find whether or not any APP is still in use 1346** 1347** Returns BOOLEAN 1348** 1349*******************************************************************************/ 1350static BOOLEAN btif_hl_is_no_active_app(void){ 1351 BOOLEAN no_active_app = TRUE; 1352 UINT8 i; 1353 1354 for (i=0; i < BTA_HL_NUM_APPS ; i ++) 1355 { 1356 if (btif_hl_cb.acb[i].in_use) 1357 { 1358 no_active_app = FALSE; 1359 break; 1360 } 1361 } 1362 1363 BTIF_TRACE_DEBUG("%s no_active_app=%d ", __FUNCTION__, no_active_app ); 1364 return no_active_app; 1365} 1366 1367/******************************************************************************* 1368** 1369** Function btif_hl_free_app_idx 1370** 1371** Description free an application control block 1372** 1373** Returns void 1374** 1375*******************************************************************************/ 1376static void btif_hl_free_app_idx(UINT8 app_idx){ 1377 1378 if ((app_idx < BTA_HL_NUM_APPS) && btif_hl_cb.acb[app_idx].in_use ) 1379 { 1380 btif_hl_cb.acb[app_idx].in_use = FALSE; 1381 memset (&btif_hl_cb.acb[app_idx], 0, sizeof(btif_hl_app_cb_t)); 1382 } 1383} 1384/******************************************************************************* 1385** 1386** Function btif_hl_set_state 1387** 1388** Description set HL state 1389** 1390** Returns void 1391** 1392*******************************************************************************/ 1393static void btif_hl_set_state(btif_hl_state_t state){ 1394 BTIF_TRACE_DEBUG("btif_hl_set_state: %d ---> %d ", p_btif_hl_cb->state, state); 1395 p_btif_hl_cb->state = state; 1396} 1397 1398/******************************************************************************* 1399** 1400** Function btif_hl_set_state 1401** 1402** Description get HL state 1403** 1404** Returns btif_hl_state_t 1405** 1406*******************************************************************************/ 1407 1408static btif_hl_state_t btif_hl_get_state(void){ 1409 BTIF_TRACE_DEBUG("btif_hl_get_state: %d ", p_btif_hl_cb->state); 1410 return p_btif_hl_cb->state; 1411} 1412 1413/******************************************************************************* 1414** 1415** Function btif_hl_find_data_type_idx 1416** 1417** Description Find the index in the data type table 1418** 1419** Returns BOOLEAN 1420** 1421*******************************************************************************/ 1422static BOOLEAN btif_hl_find_data_type_idx(UINT16 data_type, UINT8 *p_idx){ 1423 BOOLEAN found = FALSE; 1424 UINT8 i; 1425 1426 for (i=0; i< BTIF_HL_DATA_TABLE_SIZE; i++ ) 1427 { 1428 if (data_type_table[i].data_type == data_type) 1429 { 1430 found = TRUE; 1431 *p_idx= i; 1432 break; 1433 } 1434 } 1435 1436 BTIF_TRACE_DEBUG("%s found=%d, data_type=0x%x idx=%d", __FUNCTION__, found, data_type, i); 1437 return found; 1438} 1439 1440/******************************************************************************* 1441** 1442** Function btif_hl_get_max_tx_apdu_size 1443** 1444** Description Find the maximum TX APDU size for the specified data type and 1445** MDEP role 1446** 1447** Returns UINT16 1448** 1449*******************************************************************************/ 1450UINT16 btif_hl_get_max_tx_apdu_size(tBTA_HL_MDEP_ROLE mdep_role, 1451 UINT16 data_type ){ 1452 UINT8 idx; 1453 UINT16 max_tx_apdu_size =0; 1454 1455 if (btif_hl_find_data_type_idx(data_type, &idx)) 1456 { 1457 if (mdep_role == BTA_HL_MDEP_ROLE_SOURCE) 1458 { 1459 max_tx_apdu_size = data_type_table[idx].max_tx_apdu_size; 1460 } 1461 else 1462 { 1463 max_tx_apdu_size = data_type_table[idx].max_rx_apdu_size; 1464 } 1465 } 1466 else 1467 { 1468 if (mdep_role == BTA_HL_MDEP_ROLE_SOURCE) 1469 { 1470 max_tx_apdu_size = BTIF_HL_DEFAULT_SRC_TX_APDU_SIZE; 1471 } 1472 else 1473 { 1474 max_tx_apdu_size = BTIF_HL_DEFAULT_SRC_RX_APDU_SIZE; 1475 } 1476 1477 1478 } 1479 1480 BTIF_TRACE_DEBUG("%s mdep_role=%d data_type=0x%4x size=%d", 1481 __FUNCTION__, mdep_role, data_type, max_tx_apdu_size); 1482 return max_tx_apdu_size; 1483} 1484 1485 1486/******************************************************************************* 1487** 1488** Function btif_hl_get_max_rx_apdu_size 1489** 1490** Description Find the maximum RX APDU size for the specified data type and 1491** MDEP role 1492** 1493** Returns UINT16 1494** 1495*******************************************************************************/ 1496UINT16 btif_hl_get_max_rx_apdu_size(tBTA_HL_MDEP_ROLE mdep_role, 1497 UINT16 data_type ){ 1498 UINT8 idx; 1499 UINT16 max_rx_apdu_size =0; 1500 1501 if (btif_hl_find_data_type_idx(data_type, &idx)) 1502 { 1503 if (mdep_role == BTA_HL_MDEP_ROLE_SOURCE) 1504 { 1505 max_rx_apdu_size = data_type_table[idx].max_rx_apdu_size; 1506 } 1507 else 1508 { 1509 max_rx_apdu_size = data_type_table[idx].max_tx_apdu_size; 1510 } 1511 } 1512 else 1513 { 1514 if (mdep_role == BTA_HL_MDEP_ROLE_SOURCE) 1515 { 1516 max_rx_apdu_size = BTIF_HL_DEFAULT_SRC_RX_APDU_SIZE; 1517 } 1518 else 1519 { 1520 max_rx_apdu_size = BTIF_HL_DEFAULT_SRC_TX_APDU_SIZE; 1521 } 1522 } 1523 1524 1525 BTIF_TRACE_DEBUG("%s mdep_role=%d data_type=0x%4x size=%d", 1526 __FUNCTION__, mdep_role, data_type, max_rx_apdu_size); 1527 1528 return max_rx_apdu_size; 1529} 1530 1531/******************************************************************************* 1532** 1533** Function btif_hl_if_channel_setup_pending 1534** 1535** Description 1536** 1537** Returns BOOLEAN 1538** 1539*******************************************************************************/ 1540 1541static BOOLEAN btif_hl_get_bta_mdep_role(bthl_mdep_role_t mdep, tBTA_HL_MDEP_ROLE *p){ 1542 BOOLEAN status = TRUE; 1543 switch (mdep) 1544 { 1545 case BTHL_MDEP_ROLE_SOURCE: 1546 *p = BTA_HL_MDEP_ROLE_SOURCE; 1547 break; 1548 case BTHL_MDEP_ROLE_SINK: 1549 *p = BTA_HL_MDEP_ROLE_SINK; 1550 break; 1551 default: 1552 *p = BTA_HL_MDEP_ROLE_SOURCE; 1553 status = FALSE; 1554 break; 1555 } 1556 1557 BTIF_TRACE_DEBUG("%s status=%d bta_mdep_role=%d (%d:btif)", 1558 __FUNCTION__, status, *p, mdep); 1559 return status; 1560} 1561/******************************************************************************* 1562** 1563** Function btif_hl_get_bta_channel_type 1564** 1565** Description convert bthl channel type to BTA DCH channel type 1566** 1567** Returns BOOLEAN 1568** 1569*******************************************************************************/ 1570 1571static BOOLEAN btif_hl_get_bta_channel_type(bthl_channel_type_t channel_type, tBTA_HL_DCH_CFG *p){ 1572 BOOLEAN status = TRUE; 1573 switch (channel_type) 1574 { 1575 case BTHL_CHANNEL_TYPE_RELIABLE: 1576 *p = BTA_HL_DCH_CFG_RELIABLE; 1577 break; 1578 case BTHL_CHANNEL_TYPE_STREAMING: 1579 *p = BTA_HL_DCH_CFG_STREAMING; 1580 break; 1581 case BTHL_CHANNEL_TYPE_ANY: 1582 *p = BTA_HL_DCH_CFG_NO_PREF; 1583 break; 1584 default: 1585 status = FALSE; 1586 break; 1587 } 1588 BTIF_TRACE_DEBUG("%s status = %d BTA DCH CFG=%d (1-rel 2-strm", 1589 __FUNCTION__, status, *p); 1590 return status; 1591} 1592/******************************************************************************* 1593** 1594** Function btif_hl_get_next_app_id 1595** 1596** Description get next applcation id 1597** 1598** Returns UINT8 1599** 1600*******************************************************************************/ 1601 1602static UINT8 btif_hl_get_next_app_id(){ 1603 UINT8 next_app_id = btif_hl_cb.next_app_id; 1604 1605 btif_hl_cb.next_app_id++; 1606 return next_app_id; 1607} 1608/******************************************************************************* 1609** 1610** Function btif_hl_get_next_channel_id 1611** 1612** Description get next channel id 1613** 1614** Returns int 1615** 1616*******************************************************************************/ 1617static int btif_hl_get_next_channel_id(UINT8 app_id){ 1618 UINT16 next_channel_id = btif_hl_cb.next_channel_id; 1619 int channel_id; 1620 btif_hl_cb.next_channel_id++; 1621 channel_id = (app_id << 16) + next_channel_id; 1622 BTIF_TRACE_DEBUG("%s channel_id=0x%08x, app_id=0x%02x next_channel_id=0x%04x", __FUNCTION__, 1623 channel_id, app_id, next_channel_id); 1624 return channel_id; 1625} 1626/******************************************************************************* 1627** 1628** Function btif_hl_get_app_id 1629** 1630** Description get the applicaiton id associated with the channel id 1631** 1632** Returns UINT8 1633** 1634*******************************************************************************/ 1635 1636static UINT8 btif_hl_get_app_id(int channel_id){ 1637 UINT8 app_id =(UINT8) (channel_id >> 16); 1638 BTIF_TRACE_DEBUG("%s channel_id=0x%08x, app_id=0x%02x ", __FUNCTION__,channel_id, app_id); 1639 return app_id; 1640} 1641/******************************************************************************* 1642** 1643** Function btif_hl_init_next_app_id 1644** 1645** Description initialize the application id 1646** 1647** Returns void 1648** 1649*******************************************************************************/ 1650static void btif_hl_init_next_app_id(void){ 1651 btif_hl_cb.next_app_id = 1; 1652} 1653/******************************************************************************* 1654** 1655** Function btif_hl_init_next_channel_id 1656** 1657** Description initialize the channel id 1658** 1659** Returns void 1660** 1661*******************************************************************************/ 1662static void btif_hl_init_next_channel_id(void){ 1663 btif_hl_cb.next_channel_id = 1; 1664} 1665 1666 1667/******************************************************************************* 1668** 1669** Function btif_hl_find_app_idx_using_handle 1670** 1671** Description Find the applicaiton index using handle 1672** 1673** Returns BOOLEAN 1674** 1675*******************************************************************************/ 1676BOOLEAN btif_hl_find_app_idx_using_handle(tBTA_HL_APP_HANDLE app_handle, 1677 UINT8 *p_app_idx){ 1678 BOOLEAN found=FALSE; 1679 UINT8 i; 1680 1681 for (i=0; i < BTA_HL_NUM_APPS ; i ++) 1682 { 1683 if (btif_hl_cb.acb[i].in_use && 1684 (btif_hl_cb.acb[i].app_handle == app_handle)) 1685 { 1686 found = TRUE; 1687 *p_app_idx = i; 1688 break; 1689 } 1690 } 1691 1692 BTIF_TRACE_EVENT("%s status=%d handle=%d app_idx=%d ", 1693 __FUNCTION__, found, app_handle , i); 1694 1695 return found; 1696} 1697 1698/******************************************************************************* 1699** 1700** Function btif_hl_find_app_idx_using_app_id 1701** 1702** Description Find the applicaiton index using app_id 1703** 1704** Returns BOOLEAN 1705** 1706*******************************************************************************/ 1707BOOLEAN btif_hl_find_app_idx_using_app_id(UINT8 app_id, 1708 UINT8 *p_app_idx){ 1709 BOOLEAN found=FALSE; 1710 UINT8 i; 1711 1712 *p_app_idx = 0; 1713 for (i=0; i < BTA_HL_NUM_APPS ; i ++) 1714 { 1715 if (btif_hl_cb.acb[i].in_use && 1716 (btif_hl_cb.acb[i].app_id == app_id)) 1717 { 1718 found = TRUE; 1719 *p_app_idx = i; 1720 break; 1721 } 1722 } 1723 1724 BTIF_TRACE_EVENT("%s found=%d app_id=%d app_idx=%d ", 1725 __FUNCTION__, found, app_id , i); 1726 1727 return found; 1728} 1729 1730/******************************************************************************* 1731** 1732** Function btif_hl_find_mcl_idx_using_handle 1733** 1734** Description Find the MCL index using handle 1735** 1736** Returns BOOLEAN 1737** 1738*******************************************************************************/ 1739BOOLEAN btif_hl_find_mcl_idx_using_handle( tBTA_HL_MCL_HANDLE mcl_handle, 1740 UINT8 *p_app_idx, UINT8 *p_mcl_idx){ 1741 btif_hl_app_cb_t *p_acb; 1742 BOOLEAN found=FALSE; 1743 UINT8 i,j; 1744 1745 for (i=0; i<BTA_HL_NUM_APPS; i++) 1746 { 1747 p_acb =BTIF_HL_GET_APP_CB_PTR(i); 1748 for (j=0; j < BTA_HL_NUM_MCLS ; j++) 1749 { 1750 if (p_acb->mcb[j].in_use) 1751 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_handle:app_idx=%d," 1752 "mcl_idx =%d mcl_handle=%d",i,j,p_acb->mcb[j].mcl_handle); 1753 if (p_acb->mcb[j].in_use && 1754 (p_acb->mcb[j].mcl_handle == mcl_handle)) 1755 { 1756 found = TRUE; 1757 *p_app_idx = i; 1758 *p_mcl_idx = j; 1759 break; 1760 } 1761 } 1762 } 1763 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d mcl_idx=%d",__FUNCTION__, 1764 found, i, j); 1765 return found; 1766} 1767 1768/******************************************************************************* 1769** 1770** Function btif_hl_find_mdl_idx_using_mdl_id 1771** 1772** Description Find the mdl index using mdl_id 1773** 1774** Returns BOOLEAN 1775** 1776*******************************************************************************/ 1777BOOLEAN btif_hl_find_mcl_idx_using_mdl_id( UINT8 mdl_id,UINT8 mcl_handle, 1778 UINT8 *p_app_idx, UINT8 *p_mcl_idx){ 1779 btif_hl_app_cb_t *p_acb; 1780 btif_hl_mcl_cb_t *p_mcb; 1781 BOOLEAN found=FALSE; 1782 UINT8 i,j,x; 1783 1784 for (i=0; i<BTA_HL_NUM_APPS; i++) 1785 { 1786 p_acb =BTIF_HL_GET_APP_CB_PTR(i); 1787 for (j=0; j < BTA_HL_NUM_MCLS ; j++) 1788 { 1789 if (p_acb->mcb[j].in_use && 1790 (p_acb->mcb[j].mcl_handle == mcl_handle)) 1791 { 1792 p_mcb = &p_acb->mcb[j]; 1793 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_mdl_id: mcl handle found j =%d",j); 1794 for (x=0; x < BTA_HL_NUM_MDLS_PER_MCL ; x ++) 1795 { 1796 if (p_mcb->mdl[x].in_use && p_mcb->mdl[x].mdl_id == mdl_id) 1797 { 1798 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_mdl_id:found x =%d",x); 1799 found = TRUE; 1800 *p_app_idx = i; 1801 *p_mcl_idx = j; 1802 break; 1803 } 1804 } 1805 } 1806 } 1807 } 1808 BTIF_TRACE_DEBUG("%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_mcl_idx_using_deleted_mdl_id 1816** 1817** Description Find the app index deleted_mdl_id 1818** 1819** Returns BOOLEAN 1820** 1821*******************************************************************************/ 1822BOOLEAN btif_hl_find_app_idx_using_deleted_mdl_id( UINT8 mdl_id, 1823 UINT8 *p_app_idx){ 1824 btif_hl_app_cb_t *p_acb; 1825 BOOLEAN found=FALSE; 1826 UINT8 i; 1827 1828 for (i=0; i<BTA_HL_NUM_APPS; i++) 1829 { 1830 p_acb =BTIF_HL_GET_APP_CB_PTR(i); 1831 if (p_acb->delete_mdl.active) { 1832 BTIF_TRACE_DEBUG("btif_hl_find_app_idx_using_deleted_mdl_id: app_idx=%d," 1833 "mdl_id=%d mcl_handle=%d",i,mdl_id,p_acb->mcb[i].mcl_handle); 1834 } 1835 if (p_acb->delete_mdl.active && 1836 (p_acb->delete_mdl.mdl_id == mdl_id)) 1837 { 1838 found = TRUE; 1839 *p_app_idx = i; 1840 break; 1841 } 1842 } 1843 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d",__FUNCTION__, 1844 found, i); 1845 return found; 1846} 1847 1848/******************************************************************************* 1849** 1850** Function btif_hl_stop_timer_using_handle 1851** 1852** Description clean control channel cb using handle 1853** 1854** Returns void 1855** 1856*******************************************************************************/ 1857static void btif_hl_stop_timer_using_handle( tBTA_HL_MCL_HANDLE mcl_handle){ 1858 btif_hl_app_cb_t *p_acb; 1859 BOOLEAN found=FALSE; 1860 UINT8 i,j; 1861 1862 for (i=0; i<BTA_HL_NUM_APPS; i++) 1863 { 1864 p_acb =BTIF_HL_GET_APP_CB_PTR(i); 1865 for (j=0; j < BTA_HL_NUM_MCLS ; j++) 1866 { 1867 if (p_acb->mcb[j].in_use && 1868 (p_acb->mcb[j].mcl_handle == mcl_handle)) 1869 { 1870 btif_hl_stop_cch_timer(i, j); 1871 } 1872 } 1873 } 1874} 1875 1876/******************************************************************************* 1877** 1878** Function btif_hl_find_mcl_idx_using_app_idx 1879** 1880** Description Find the MCL index using handle 1881** 1882** Returns BOOLEAN 1883** 1884*******************************************************************************/ 1885BOOLEAN btif_hl_find_mcl_idx_using_app_idx( tBTA_HL_MCL_HANDLE mcl_handle, 1886 UINT8 p_app_idx, UINT8 *p_mcl_idx){ 1887 btif_hl_app_cb_t *p_acb; 1888 BOOLEAN found=FALSE; 1889 UINT8 i,j; 1890 1891 p_acb =BTIF_HL_GET_APP_CB_PTR(p_app_idx); 1892 for (j=0; j < BTA_HL_NUM_MCLS ; j++) 1893 { 1894 if (p_acb->mcb[j].in_use && 1895 (p_acb->mcb[j].mcl_handle == mcl_handle)) 1896 { 1897 found = TRUE; 1898 *p_mcl_idx = j; 1899 break; 1900 } 1901 } 1902 BTIF_TRACE_DEBUG("%s found=%dmcl_idx=%d",__FUNCTION__, 1903 found, j); 1904 return found; 1905} 1906 1907/******************************************************************************* 1908** 1909** Function btif_hl_clean_mdls_using_app_idx 1910** 1911** Description clean dch cpntrol bloack using app_idx 1912** 1913** Returns void 1914** 1915*******************************************************************************/ 1916void btif_hl_clean_mdls_using_app_idx( UINT8 app_idx){ 1917 btif_hl_app_cb_t *p_acb; 1918 btif_hl_mcl_cb_t *p_mcb; 1919 btif_hl_mdl_cb_t *p_dcb; 1920 UINT8 i,j,x,y; 1921 bt_bdaddr_t bd_addr; 1922 1923 p_acb =BTIF_HL_GET_APP_CB_PTR(app_idx); 1924 for (j=0; j < BTA_HL_NUM_MCLS ; j++) 1925 { 1926 if (p_acb->mcb[j].in_use) 1927 { 1928 p_mcb = &p_acb->mcb[j]; 1929 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_mdl_id: mcl handle found j =%d",j); 1930 for (x=0; x < BTA_HL_NUM_MDLS_PER_MCL ; x ++) 1931 { 1932 if (p_mcb->mdl[x].in_use) 1933 { 1934 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, j,x); 1935 btif_hl_release_socket(app_idx,j,x); 1936 for (y=0; y<6; y++) 1937 { 1938 bd_addr.address[y] = p_mcb->bd_addr[y]; 1939 } 1940 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, p_acb->app_id, 1941 &bd_addr, p_dcb->local_mdep_cfg_idx, 1942 p_dcb->channel_id, BTHL_CONN_STATE_DISCONNECTED, 0 ); 1943 btif_hl_clean_mdl_cb(p_dcb); 1944 if (!btif_hl_num_dchs_in_use(p_mcb->mcl_handle)) 1945 BTA_HlCchClose(p_mcb->mcl_handle); 1946 BTIF_TRACE_DEBUG("remote DCH close success mdl_idx=%d", x); 1947 } 1948 } 1949 } 1950 } 1951} 1952 1953/******************************************************************************* 1954** 1955** Function btif_hl_find_app_idx 1956** 1957** Description Find the application index using application ID 1958** 1959** Returns BOOLEAN 1960** 1961*******************************************************************************/ 1962BOOLEAN btif_hl_find_app_idx(UINT8 app_id, UINT8 *p_app_idx){ 1963 BOOLEAN found=FALSE; 1964 UINT8 i; 1965 1966 for (i=0; i < BTA_HL_NUM_APPS ; i ++) 1967 { 1968 1969 if (btif_hl_cb.acb[i].in_use && 1970 (btif_hl_cb.acb[i].app_id == app_id)) 1971 { 1972 found = TRUE; 1973 *p_app_idx = i; 1974 break; 1975 } 1976 } 1977 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d", __FUNCTION__, found, i ); 1978 1979 return found; 1980} 1981 1982/******************************************************************************* 1983** 1984** Function btif_hl_find_app_idx 1985** 1986** Description Find the application index using application ID 1987** 1988** Returns BOOLEAN 1989** 1990*******************************************************************************/ 1991BOOLEAN btif_hl_find_app_idx_using_mdepId(UINT8 mdep_id, UINT8 *p_app_idx){ 1992 BOOLEAN found=FALSE; 1993 UINT8 i; 1994 1995 *p_app_idx = 0; 1996 for (i=0; i < BTA_HL_NUM_APPS ; i ++) 1997 { 1998 BTIF_TRACE_DEBUG("btif_hl_find_app_idx_using_mdepId: MDEP-ID = %d", 1999 btif_hl_cb.acb[i].sup_feature.mdep[0].mdep_id); 2000 if (btif_hl_cb.acb[i].in_use && 2001 (btif_hl_cb.acb[i].sup_feature.mdep[0].mdep_id == mdep_id)) 2002 { 2003 found = TRUE; 2004 *p_app_idx = i; 2005 break; 2006 } 2007 } 2008 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d", __FUNCTION__, found, i ); 2009 2010 return found; 2011} 2012 2013/******************************************************************************* 2014** 2015** Function btif_hl_find_avail_mdl_idx 2016** 2017** Description Find a not in-use MDL index 2018** 2019** Returns BOOLEAN 2020** 2021*******************************************************************************/ 2022BOOLEAN btif_hl_find_avail_mdl_idx(UINT8 app_idx, UINT8 mcl_idx, 2023 UINT8 *p_mdl_idx){ 2024 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 2025 BOOLEAN found=FALSE; 2026 UINT8 i; 2027 2028 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++) 2029 { 2030 if (!p_mcb->mdl[i].in_use) 2031 { 2032 btif_hl_clean_mdl_cb(&p_mcb->mdl[i]); 2033 found = TRUE; 2034 *p_mdl_idx = i; 2035 break; 2036 } 2037 } 2038 2039 BTIF_TRACE_DEBUG("%s found=%d idx=%d",__FUNCTION__, found, i); 2040 return found; 2041} 2042 2043/******************************************************************************* 2044** 2045** Function btif_hl_find_avail_mcl_idx 2046** 2047** Description Find a not in-use MDL index 2048** 2049** Returns BOOLEAN 2050** 2051*******************************************************************************/ 2052BOOLEAN btif_hl_find_avail_mcl_idx(UINT8 app_idx, UINT8 *p_mcl_idx){ 2053 BOOLEAN found=FALSE; 2054 UINT8 i; 2055 2056 for (i=0; i < BTA_HL_NUM_MCLS ; i ++) 2057 { 2058 if (!btif_hl_cb.acb[app_idx].mcb[i].in_use) 2059 { 2060 found = TRUE; 2061 *p_mcl_idx = i; 2062 break; 2063 } 2064 } 2065 BTIF_TRACE_DEBUG("%s found=%d mcl_idx=%d", __FUNCTION__, found, i); 2066 return found; 2067} 2068 2069/******************************************************************************* 2070** 2071** Function btif_hl_find_avail_app_idx 2072** 2073** Description Find a not in-use APP index 2074** 2075** Returns BOOLEAN 2076** 2077*******************************************************************************/ 2078static BOOLEAN btif_hl_find_avail_app_idx(UINT8 *p_idx){ 2079 BOOLEAN found = FALSE; 2080 UINT8 i; 2081 2082 for (i=0; i < BTA_HL_NUM_APPS ; i ++) 2083 { 2084 if (!btif_hl_cb.acb[i].in_use) 2085 { 2086 found = TRUE; 2087 *p_idx = i; 2088 break; 2089 } 2090 } 2091 2092 BTIF_TRACE_DEBUG("%s found=%d app_idx=%d", __FUNCTION__, found, i); 2093 return found; 2094} 2095 2096 2097/******************************************************************************* 2098** 2099** Function btif_hl_proc_dereg_cfm 2100** 2101** Description Process the de-registration confirmation 2102** 2103** Returns Nothing 2104** 2105*******************************************************************************/ 2106static void btif_hl_proc_dereg_cfm(tBTA_HL *p_data) 2107 2108{ 2109 btif_hl_app_cb_t *p_acb; 2110 UINT8 app_idx; 2111 int app_id = 0; 2112 bthl_app_reg_state_t state = BTHL_APP_REG_STATE_DEREG_SUCCESS; 2113 bt_status_t status = BT_STATUS_SUCCESS; 2114 2115 BTIF_TRACE_DEBUG("%s de-reg status=%d app_handle=%d", __FUNCTION__, 2116 p_data->dereg_cfm.status, p_data->dereg_cfm.app_handle); 2117 2118 if (btif_hl_find_app_idx_using_app_id(p_data->dereg_cfm.app_id, &app_idx)) 2119 { 2120 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 2121 app_id = (int) p_acb->app_id; 2122 if (p_data->dereg_cfm.status == BTA_HL_STATUS_OK) 2123 { 2124 btif_hl_clean_mdls_using_app_idx(app_idx); 2125 memset(p_acb, 0,sizeof(btif_hl_app_cb_t)); 2126 } 2127 else 2128 state = BTHL_APP_REG_STATE_DEREG_FAILED; 2129 2130 BTIF_TRACE_DEBUG("call reg state callback app_id=%d state=%d", app_id, state); 2131 BTIF_HL_CALL_CBACK(bt_hl_callbacks, app_reg_state_cb, app_id, state ); 2132 2133 if (btif_hl_is_no_active_app()) 2134 { 2135 btif_hl_disable(); 2136 } 2137 } 2138} 2139 2140/******************************************************************************* 2141** 2142** Function btif_hl_proc_reg_cfm 2143** 2144** Description Process the registration confirmation 2145** 2146** Returns Nothing 2147** 2148*******************************************************************************/ 2149static void btif_hl_proc_reg_cfm(tBTA_HL *p_data){ 2150 btif_hl_app_cb_t *p_acb; 2151 UINT8 app_idx; 2152 bthl_app_reg_state_t state = BTHL_APP_REG_STATE_REG_SUCCESS; 2153 bt_status_t bt_status; 2154 2155 BTIF_TRACE_DEBUG("%s reg status=%d app_handle=%d", __FUNCTION__, p_data->reg_cfm.status, p_data->reg_cfm.app_handle); 2156 2157 if (btif_hl_find_app_idx(p_data->reg_cfm.app_id, &app_idx)) 2158 { 2159 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 2160 if (p_data->reg_cfm.status == BTA_HL_STATUS_OK) 2161 { 2162 p_acb->app_handle = p_data->reg_cfm.app_handle; 2163 } 2164 else 2165 { 2166 btif_hl_free_app_idx(app_idx); 2167 reg_counter--; 2168 state = BTHL_APP_REG_STATE_REG_FAILED; 2169 } 2170 2171 BTIF_TRACE_DEBUG("%s call reg state callback app_id=%d reg state=%d", __FUNCTION__, p_data->reg_cfm.app_id, state); 2172 BTIF_HL_CALL_CBACK(bt_hl_callbacks, app_reg_state_cb, ((int) p_data->reg_cfm.app_id), state ); 2173 } 2174} 2175 2176/******************************************************************************* 2177** 2178** Function btif_hl_set_chan_cb_state 2179** 2180** Description set the channel callback state 2181** 2182** Returns void 2183** 2184*******************************************************************************/ 2185void btif_hl_set_chan_cb_state(UINT8 app_idx, UINT8 mcl_idx, btif_hl_chan_cb_state_t state){ 2186 btif_hl_pending_chan_cb_t *p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx); 2187 btif_hl_chan_cb_state_t cur_state = p_pcb->cb_state; 2188 2189 if (cur_state != state) 2190 { 2191 p_pcb->cb_state = state; 2192 BTIF_TRACE_DEBUG("%s state %d--->%d",__FUNCTION__, cur_state, state); 2193 } 2194 2195 2196} 2197/******************************************************************************* 2198** 2199** Function btif_hl_send_destroyed_cb 2200** 2201** Description send the channel destroyed callback 2202** 2203** Returns void 2204** 2205*******************************************************************************/ 2206void btif_hl_send_destroyed_cb(btif_hl_app_cb_t *p_acb ){ 2207 bt_bdaddr_t bd_addr; 2208 int app_id = (int) btif_hl_get_app_id(p_acb->delete_mdl.channel_id); 2209 2210 btif_hl_copy_bda(&bd_addr, p_acb->delete_mdl.bd_addr); 2211 BTIF_TRACE_DEBUG("%s",__FUNCTION__); 2212 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d, state=%d fd=%d",p_acb->delete_mdl.channel_id, 2213 p_acb->delete_mdl.mdep_cfg_idx, BTHL_CONN_STATE_DESTROYED, 0); 2214 btif_hl_display_bt_bda(&bd_addr); 2215 2216 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id, 2217 &bd_addr, p_acb->delete_mdl.mdep_cfg_idx, 2218 p_acb->delete_mdl.channel_id, BTHL_CONN_STATE_DESTROYED, 0 ); 2219} 2220/******************************************************************************* 2221** 2222** Function btif_hl_send_disconnecting_cb 2223** 2224** Description send a channel disconnecting callback 2225** 2226** Returns void 2227** 2228*******************************************************************************/ 2229void btif_hl_send_disconnecting_cb(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx){ 2230 btif_hl_mdl_cb_t *p_dcb = BTIF_HL_GET_MDL_CB_PTR( app_idx, mcl_idx, mdl_idx); 2231 btif_hl_soc_cb_t *p_scb = p_dcb->p_scb; 2232 bt_bdaddr_t bd_addr; 2233 int app_id = (int) btif_hl_get_app_id(p_scb->channel_id); 2234 2235 btif_hl_copy_bda(&bd_addr, p_scb->bd_addr); 2236 2237 BTIF_TRACE_DEBUG("%s",__FUNCTION__); 2238 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d, state=%d fd=%d",p_scb->channel_id, 2239 p_scb->mdep_cfg_idx, BTHL_CONN_STATE_DISCONNECTING, p_scb->socket_id[0]); 2240 btif_hl_display_bt_bda(&bd_addr); 2241 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id, 2242 &bd_addr, p_scb->mdep_cfg_idx, 2243 p_scb->channel_id, BTHL_CONN_STATE_DISCONNECTING, p_scb->socket_id[0] ); 2244} 2245/******************************************************************************* 2246** 2247** Function btif_hl_send_setup_connecting_cb 2248** 2249** Description send a channel connecting callback 2250** 2251** Returns void 2252** 2253*******************************************************************************/ 2254void btif_hl_send_setup_connecting_cb(UINT8 app_idx, UINT8 mcl_idx){ 2255 btif_hl_pending_chan_cb_t *p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx); 2256 bt_bdaddr_t bd_addr; 2257 int app_id = (int) btif_hl_get_app_id(p_pcb->channel_id); 2258 2259 btif_hl_copy_bda(&bd_addr, p_pcb->bd_addr); 2260 2261 if (p_pcb->in_use && p_pcb->cb_state == BTIF_HL_CHAN_CB_STATE_CONNECTING_PENDING) 2262 { 2263 BTIF_TRACE_DEBUG("%s",__FUNCTION__); 2264 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d state=%d fd=%d",p_pcb->channel_id, 2265 p_pcb->mdep_cfg_idx, BTHL_CONN_STATE_CONNECTING, 0); 2266 btif_hl_display_bt_bda(&bd_addr); 2267 2268 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id, 2269 &bd_addr, p_pcb->mdep_cfg_idx, 2270 p_pcb->channel_id, BTHL_CONN_STATE_CONNECTING, 0 ); 2271 btif_hl_set_chan_cb_state(app_idx, mcl_idx, BTIF_HL_CHAN_CB_STATE_CONNECTED_PENDING); 2272 } 2273} 2274/******************************************************************************* 2275** 2276** Function btif_hl_send_setup_disconnected_cb 2277** 2278** Description send a channel disconnected callback 2279** 2280** Returns void 2281** 2282*******************************************************************************/ 2283void btif_hl_send_setup_disconnected_cb(UINT8 app_idx, UINT8 mcl_idx){ 2284 btif_hl_pending_chan_cb_t *p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx); 2285 bt_bdaddr_t bd_addr; 2286 int app_id = (int) btif_hl_get_app_id(p_pcb->channel_id); 2287 2288 btif_hl_copy_bda(&bd_addr, p_pcb->bd_addr); 2289 2290 BTIF_TRACE_DEBUG("%s p_pcb->in_use=%d",__FUNCTION__, p_pcb->in_use); 2291 if (p_pcb->in_use) 2292 { 2293 BTIF_TRACE_DEBUG("%p_pcb->cb_state=%d",p_pcb->cb_state); 2294 if (p_pcb->cb_state == BTIF_HL_CHAN_CB_STATE_CONNECTING_PENDING) 2295 { 2296 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d state=%d fd=%d",p_pcb->channel_id, 2297 p_pcb->mdep_cfg_idx, BTHL_CONN_STATE_CONNECTING, 0); 2298 btif_hl_display_bt_bda(&bd_addr); 2299 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id, 2300 &bd_addr, p_pcb->mdep_cfg_idx, 2301 p_pcb->channel_id, BTHL_CONN_STATE_CONNECTING, 0 ); 2302 2303 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d state=%d fd=%d",p_pcb->channel_id, 2304 p_pcb->mdep_cfg_idx, BTHL_CONN_STATE_DISCONNECTED, 0); 2305 btif_hl_display_bt_bda(&bd_addr); 2306 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id, 2307 &bd_addr, p_pcb->mdep_cfg_idx, 2308 p_pcb->channel_id, BTHL_CONN_STATE_DISCONNECTED, 0 ); 2309 } 2310 else if (p_pcb->cb_state == BTIF_HL_CHAN_CB_STATE_CONNECTED_PENDING) 2311 { 2312 BTIF_TRACE_DEBUG("call channel state callback channel_id=0x%08x mdep_cfg_idx=%d state=%d fd=%d",p_pcb->channel_id, 2313 p_pcb->mdep_cfg_idx, BTHL_CONN_STATE_DISCONNECTED, 0); 2314 btif_hl_display_bt_bda(&bd_addr); 2315 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, app_id, 2316 &bd_addr, p_pcb->mdep_cfg_idx, 2317 p_pcb->channel_id, BTHL_CONN_STATE_DISCONNECTED, 0 ); 2318 } 2319 btif_hl_clean_pcb(p_pcb); 2320 } 2321} 2322/******************************************************************************* 2323** 2324** Function btif_hl_proc_sdp_query_cfm 2325** 2326** Description Process the SDP query confirmation 2327** 2328** Returns Nothing 2329** 2330*******************************************************************************/ 2331static BOOLEAN btif_hl_proc_sdp_query_cfm(tBTA_HL *p_data){ 2332 btif_hl_app_cb_t *p_acb; 2333 btif_hl_mcl_cb_t *p_mcb; 2334 tBTA_HL_SDP *p_sdp; 2335 tBTA_HL_CCH_OPEN_PARAM open_param; 2336 UINT8 app_idx, mcl_idx, sdp_idx = 0; 2337 UINT8 num_recs, i, num_mdeps, j; 2338 btif_hl_cch_op_t old_cch_oper; 2339 BOOLEAN status =FALSE; 2340 btif_hl_pending_chan_cb_t *p_pcb; 2341 2342 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 2343 2344 p_sdp = p_data->sdp_query_cfm.p_sdp; 2345 num_recs = p_sdp->num_recs; 2346 2347 BTIF_TRACE_DEBUG("num of SDP records=%d",num_recs); 2348 for (i=0; i<num_recs; i++) 2349 { 2350 BTIF_TRACE_DEBUG("rec_idx=%d ctrl_psm=0x%x data_psm=0x%x", 2351 (i+1),p_sdp->sdp_rec[i].ctrl_psm, p_sdp->sdp_rec[i].data_psm); 2352 BTIF_TRACE_DEBUG("MCAP supported procedures=0x%x",p_sdp->sdp_rec[i].mcap_sup_proc); 2353 num_mdeps = p_sdp->sdp_rec[i].num_mdeps; 2354 BTIF_TRACE_DEBUG("num of mdeps =%d",num_mdeps); 2355 for (j=0; j< num_mdeps; j++) 2356 { 2357 BTIF_TRACE_DEBUG("mdep_idx=%d mdep_id=0x%x data_type=0x%x mdep_role=0x%x", 2358 (j+1), 2359 p_sdp->sdp_rec[i].mdep_cfg[j].mdep_id, 2360 p_sdp->sdp_rec[i].mdep_cfg[j].data_type, 2361 p_sdp->sdp_rec[i].mdep_cfg[j].mdep_role ); 2362 } 2363 } 2364 2365 if (btif_hl_find_app_idx_using_app_id(p_data->sdp_query_cfm.app_id, &app_idx)) 2366 { 2367 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 2368 2369 if (btif_hl_find_mcl_idx(app_idx, p_data->sdp_query_cfm.bd_addr, &mcl_idx)) 2370 { 2371 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 2372 if (p_mcb->cch_oper != BTIF_HL_CCH_OP_NONE) 2373 { 2374 memcpy(&p_mcb->sdp, p_sdp, sizeof(tBTA_HL_SDP)); 2375 old_cch_oper = p_mcb->cch_oper; 2376 p_mcb->cch_oper = BTIF_HL_CCH_OP_NONE; 2377 2378 switch (old_cch_oper) 2379 { 2380 case BTIF_HL_CCH_OP_MDEP_FILTERING: 2381 status = btif_hl_find_sdp_idx_using_mdep_filter(app_idx, 2382 mcl_idx, &sdp_idx); 2383 break; 2384 default: 2385 break; 2386 } 2387 2388 if (status) 2389 { 2390 p_mcb->sdp_idx = sdp_idx; 2391 p_mcb->valid_sdp_idx = TRUE; 2392 p_mcb->ctrl_psm = p_mcb->sdp.sdp_rec[sdp_idx].ctrl_psm; 2393 2394 switch (old_cch_oper) 2395 { 2396 case BTIF_HL_CCH_OP_MDEP_FILTERING: 2397 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx); 2398 if (p_pcb->in_use) 2399 { 2400 if (!p_pcb->abort_pending) 2401 { 2402 switch (p_pcb->op) 2403 { 2404 case BTIF_HL_PEND_DCH_OP_OPEN: 2405 btif_hl_send_setup_connecting_cb(app_idx, mcl_idx); 2406 break; 2407 case BTIF_HL_PEND_DCH_OP_DELETE_MDL: 2408 default: 2409 break; 2410 } 2411 open_param.ctrl_psm = p_mcb->ctrl_psm; 2412 bdcpy(open_param.bd_addr, p_mcb->bd_addr); 2413 open_param.sec_mask = 2414 (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT); 2415 BTA_HlCchOpen(p_acb->app_id,p_acb->app_handle, &open_param); 2416 } 2417 else 2418 { 2419 BTIF_TRACE_DEBUG("channel abort pending"); 2420 } 2421 } 2422 break; 2423 2424 case BTIF_HL_CCH_OP_DCH_OPEN: 2425 status = btif_hl_proc_pending_op(app_idx,mcl_idx); 2426 break; 2427 2428 default: 2429 BTIF_TRACE_ERROR("Invalid CCH oper %d", old_cch_oper); 2430 break; 2431 } 2432 } 2433 else 2434 { 2435 BTIF_TRACE_ERROR("Can not find SDP idx discard CCH Open request"); 2436 } 2437 } 2438 } 2439 } 2440 return status; 2441} 2442 2443 2444/******************************************************************************* 2445** 2446** Function btif_hl_proc_cch_open_ind 2447** 2448** Description Process the CCH open indication 2449** 2450** Returns Nothing 2451** 2452*******************************************************************************/ 2453static void btif_hl_proc_cch_open_ind(tBTA_HL *p_data) 2454 2455{ 2456 btif_hl_mcl_cb_t *p_mcb; 2457 UINT8 app_idx, mcl_idx; 2458 int i; 2459 2460 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 2461 for(i=0; i<BTA_HL_NUM_APPS; i++) 2462 { 2463 if (btif_hl_cb.acb[i].in_use) 2464 { 2465 if (!btif_hl_find_mcl_idx(i, p_data->cch_open_ind.bd_addr, &mcl_idx)) 2466 { 2467 if (btif_hl_find_avail_mcl_idx(i, &mcl_idx)) 2468 { 2469 p_mcb = BTIF_HL_GET_MCL_CB_PTR(i, mcl_idx); 2470 memset(p_mcb, 0, sizeof(btif_hl_mcl_cb_t)); 2471 p_mcb->in_use = TRUE; 2472 p_mcb->is_connected = TRUE; 2473 p_mcb->mcl_handle = p_data->cch_open_ind.mcl_handle; 2474 bdcpy(p_mcb->bd_addr, p_data->cch_open_ind.bd_addr); 2475 btif_hl_start_cch_timer(i, mcl_idx); 2476 } 2477 } 2478 else 2479 { 2480 BTIF_TRACE_ERROR("The MCL already exist for cch_open_ind"); 2481 } 2482 } 2483 } 2484} 2485 2486/******************************************************************************* 2487** 2488** Function btif_hl_proc_pending_op 2489** 2490** Description Process the pending dch operation. 2491** 2492** Returns Nothing 2493** 2494*******************************************************************************/ 2495BOOLEAN btif_hl_proc_pending_op(UINT8 app_idx, UINT8 mcl_idx) 2496 2497{ 2498 2499 btif_hl_app_cb_t *p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 2500 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 2501 btif_hl_pending_chan_cb_t *p_pcb; 2502 BOOLEAN status = FALSE; 2503 tBTA_HL_DCH_OPEN_PARAM dch_open; 2504 tBTA_HL_MDL_ID mdl_id; 2505 tBTA_HL_DCH_RECONNECT_PARAM reconnect_param; 2506 2507 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx); 2508 if (p_pcb->in_use) 2509 { 2510 switch (p_pcb->op) 2511 { 2512 case BTIF_HL_PEND_DCH_OP_OPEN: 2513 if (!p_pcb->abort_pending) 2514 { 2515 BTIF_TRACE_DEBUG("op BTIF_HL_PEND_DCH_OP_OPEN"); 2516 dch_open.ctrl_psm = p_mcb->ctrl_psm; 2517 dch_open.local_mdep_id = p_acb->sup_feature.mdep[p_pcb->mdep_cfg_idx].mdep_id; 2518 if (btif_hl_find_peer_mdep_id(p_acb->app_id, p_mcb->bd_addr, 2519 p_acb->sup_feature.mdep[p_pcb->mdep_cfg_idx].mdep_cfg.mdep_role, 2520 p_acb->sup_feature.mdep[p_pcb->mdep_cfg_idx].mdep_cfg.data_cfg[0].data_type, &dch_open.peer_mdep_id )) 2521 { 2522 dch_open.local_cfg = p_acb->channel_type[p_pcb->mdep_cfg_idx]; 2523 if ((p_acb->sup_feature.mdep[p_pcb->mdep_cfg_idx].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SOURCE) 2524 && !btif_hl_is_the_first_reliable_existed(app_idx, mcl_idx)) 2525 { 2526 dch_open.local_cfg = BTA_HL_DCH_CFG_RELIABLE; 2527 } 2528 dch_open.sec_mask = (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT); 2529 BTIF_TRACE_DEBUG("dch_open.local_cfg=%d ", dch_open.local_cfg); 2530 btif_hl_send_setup_connecting_cb(app_idx,mcl_idx); 2531 2532 if (!btif_hl_is_reconnect_possible(app_idx, mcl_idx, p_pcb->mdep_cfg_idx, &dch_open, &mdl_id )) 2533 { 2534 BTIF_TRACE_DEBUG("Issue DCH open, mcl_handle=%d",p_mcb->mcl_handle); 2535 BTA_HlDchOpen(p_mcb->mcl_handle, &dch_open); 2536 } 2537 else 2538 { 2539 reconnect_param.ctrl_psm = p_mcb->ctrl_psm; 2540 reconnect_param.mdl_id = mdl_id;; 2541 BTIF_TRACE_DEBUG("Issue Reconnect ctrl_psm=0x%x mdl_id=0x%x",reconnect_param.ctrl_psm, reconnect_param.mdl_id); 2542 BTA_HlDchReconnect(p_mcb->mcl_handle, &reconnect_param); 2543 } 2544 status = TRUE; 2545 } 2546 } 2547 else 2548 { 2549 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx); 2550 status = TRUE; 2551 } 2552 break; 2553 case BTIF_HL_PEND_DCH_OP_DELETE_MDL: 2554 BTA_HlDeleteMdl(p_mcb->mcl_handle, p_acb->delete_mdl.mdl_id); 2555 status = TRUE; 2556 break; 2557 2558 default: 2559 break; 2560 } 2561 } 2562 return status; 2563} 2564 2565/******************************************************************************* 2566** 2567** Function btif_hl_proc_cch_open_cfm 2568** 2569** Description Process the CCH open confirmation 2570** 2571** Returns Nothing 2572** 2573*******************************************************************************/ 2574static BOOLEAN btif_hl_proc_cch_open_cfm(tBTA_HL *p_data) 2575 2576{ 2577 btif_hl_app_cb_t *p_acb; 2578 btif_hl_mcl_cb_t *p_mcb; 2579 UINT8 app_idx, mcl_idx; 2580 BOOLEAN status = FALSE; 2581 tBTA_HL_DCH_OPEN_PARAM dch_open; 2582 2583 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 2584 2585 if (btif_hl_find_app_idx_using_app_id(p_data->cch_open_cfm.app_id, &app_idx)) 2586 { 2587 BTIF_TRACE_DEBUG("app_idx=%d", app_idx); 2588 if (btif_hl_find_mcl_idx(app_idx, p_data->cch_open_cfm.bd_addr, &mcl_idx)) 2589 { 2590 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 2591 2592 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 2593 BTIF_TRACE_DEBUG("mcl_idx=%d, mcl_handle=%d", mcl_idx,p_data->cch_open_cfm.mcl_handle); 2594 p_mcb->mcl_handle = p_data->cch_open_cfm.mcl_handle; 2595 p_mcb->is_connected = TRUE; 2596 status = btif_hl_proc_pending_op(app_idx, mcl_idx); 2597 if (status) 2598 btif_hl_start_cch_timer(app_idx, mcl_idx); 2599 } 2600 } 2601 2602 return status; 2603} 2604 2605/******************************************************************************* 2606** 2607** Function btif_hl_clean_mcb_using_handle 2608** 2609** Description clean control channel cb using handle 2610** 2611** Returns void 2612** 2613*******************************************************************************/ 2614static void btif_hl_clean_mcb_using_handle( tBTA_HL_MCL_HANDLE mcl_handle){ 2615 btif_hl_app_cb_t *p_acb; 2616 UINT8 i,j; 2617 2618 for (i=0; i<BTA_HL_NUM_APPS; i++) 2619 { 2620 p_acb =BTIF_HL_GET_APP_CB_PTR(i); 2621 for (j=0; j < BTA_HL_NUM_MCLS ; j++) 2622 { 2623 if (p_acb->mcb[j].in_use) 2624 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_handle: app_idx=%d," 2625 "mcl_idx =%d mcl_handle=%d",i,j,p_acb->mcb[j].mcl_handle); 2626 if (p_acb->mcb[j].in_use && 2627 (p_acb->mcb[j].mcl_handle == mcl_handle)) 2628 { 2629 btif_hl_stop_cch_timer(i, j); 2630 btif_hl_release_mcl_sockets(i, j); 2631 btif_hl_send_setup_disconnected_cb(i, j); 2632 btif_hl_clean_mcl_cb(i, j); 2633 } 2634 } 2635 } 2636} 2637 2638/******************************************************************************* 2639** 2640** Function btif_hl_proc_cch_close_ind 2641** 2642** Description Process the CCH close indication 2643** 2644** Returns Nothing 2645** 2646*******************************************************************************/ 2647static void btif_hl_proc_cch_close_ind(tBTA_HL *p_data) 2648 2649{ 2650 UINT8 app_idx, mcl_idx; 2651 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 2652 2653 btif_hl_clean_mcb_using_handle(p_data->cch_close_ind.mcl_handle); 2654} 2655 2656 2657/******************************************************************************* 2658** 2659** Function btif_hl_proc_cch_close_cfm 2660** 2661** Description Process the CCH close confirmation 2662** 2663** Returns Nothing 2664** 2665*******************************************************************************/ 2666static void btif_hl_proc_cch_close_cfm(tBTA_HL *p_data) 2667{ 2668 UINT8 app_idx, mcl_idx; 2669 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 2670 2671 btif_hl_clean_mcb_using_handle(p_data->cch_close_ind.mcl_handle); 2672} 2673 2674/******************************************************************************* 2675** 2676** Function btif_hl_proc_create_ind 2677** 2678** Description Process the MDL create indication 2679** 2680** Returns Nothing 2681** 2682*******************************************************************************/ 2683static void btif_hl_proc_create_ind(tBTA_HL *p_data){ 2684 btif_hl_app_cb_t *p_acb; 2685 btif_hl_mcl_cb_t *p_mcb; 2686 tBTA_HL_MDEP *p_mdep; 2687 UINT8 app_idx, orig_app_idx, mcl_idx, mdep_cfg_idx; 2688 BOOLEAN first_reliable_exist; 2689 BOOLEAN success = TRUE; 2690 tBTA_HL_DCH_CFG rsp_cfg = BTA_HL_DCH_CFG_UNKNOWN; 2691 tBTA_HL_DCH_CREATE_RSP rsp_code = BTA_HL_DCH_CREATE_RSP_CFG_REJ; 2692 tBTA_HL_DCH_CREATE_RSP_PARAM create_rsp_param; 2693 2694 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 2695 2696// Find the correct app_idx based on the mdep_id; 2697 btif_hl_find_app_idx_using_mdepId(p_data->dch_create_ind.local_mdep_id,&orig_app_idx); 2698 if (btif_hl_find_mcl_idx(orig_app_idx, p_data->dch_create_ind.bd_addr, &mcl_idx)) 2699 { 2700 p_acb =BTIF_HL_GET_APP_CB_PTR(orig_app_idx); 2701 p_mcb =BTIF_HL_GET_MCL_CB_PTR(orig_app_idx, mcl_idx); 2702 2703 if (btif_hl_find_mdep_cfg_idx(orig_app_idx, p_data->dch_create_ind.local_mdep_id, &mdep_cfg_idx)) 2704 { 2705 p_mdep = &(p_acb->sup_feature.mdep[mdep_cfg_idx]); 2706 first_reliable_exist = btif_hl_is_the_first_reliable_existed(orig_app_idx, mcl_idx); 2707 switch (p_mdep->mdep_cfg.mdep_role) 2708 { 2709 case BTA_HL_MDEP_ROLE_SOURCE: 2710 if (p_data->dch_create_ind.cfg == BTA_HL_DCH_CFG_NO_PREF) 2711 { 2712 if (first_reliable_exist) 2713 { 2714 rsp_cfg = p_acb->channel_type[mdep_cfg_idx]; 2715 } 2716 else 2717 { 2718 rsp_cfg = BTA_HL_DCH_CFG_RELIABLE; 2719 } 2720 rsp_code = BTA_HL_DCH_CREATE_RSP_SUCCESS; 2721 } 2722 2723 break; 2724 case BTA_HL_MDEP_ROLE_SINK: 2725 2726 BTIF_TRACE_DEBUG("btif_hl_proc_create_ind:BTA_HL_MDEP_ROLE_SINK"); 2727 if ((p_data->dch_create_ind.cfg == BTA_HL_DCH_CFG_RELIABLE) || 2728 (first_reliable_exist && (p_data->dch_create_ind.cfg == BTA_HL_DCH_CFG_STREAMING))) 2729 { 2730 rsp_code = BTA_HL_DCH_CREATE_RSP_SUCCESS; 2731 rsp_cfg = p_data->dch_create_ind.cfg; 2732 BTIF_TRACE_DEBUG("btif_hl_proc_create_ind:BTA_HL_MDEP_ROLE_SINK cfg = %d",rsp_cfg); 2733 } 2734 break; 2735 default: 2736 break; 2737 } 2738 } 2739 } 2740 else 2741 { 2742 success = FALSE; 2743 } 2744 2745 if (success) 2746 { 2747 BTIF_TRACE_DEBUG("create response rsp_code=%d rsp_cfg=%d", rsp_code, rsp_cfg ); 2748 create_rsp_param.local_mdep_id = p_data->dch_create_ind.local_mdep_id; 2749 create_rsp_param.mdl_id = p_data->dch_create_ind.mdl_id; 2750 create_rsp_param.rsp_code = rsp_code; 2751 create_rsp_param.cfg_rsp = rsp_cfg; 2752 BTA_HlDchCreateRsp(p_mcb->mcl_handle, &create_rsp_param); 2753 } 2754} 2755 2756/******************************************************************************* 2757** 2758** Function btif_hl_proc_dch_open_ind 2759** 2760** Description Process the DCH open indication 2761** 2762** Returns Nothing 2763** 2764*******************************************************************************/ 2765static void btif_hl_proc_dch_open_ind(tBTA_HL *p_data) 2766 2767{ 2768 btif_hl_app_cb_t *p_acb; 2769 btif_hl_mcl_cb_t *p_mcb; 2770 btif_hl_mdl_cb_t *p_dcb; 2771 UINT8 orig_app_idx, mcl_idx, mdl_idx, mdep_cfg_idx; 2772 UINT8 dc_cfg; 2773 BOOLEAN close_dch = FALSE; 2774 2775 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 2776 2777 // Find the correct app_idx based on the mdep_id; 2778 btif_hl_find_app_idx_using_mdepId(p_data->dch_open_ind.local_mdep_id,&orig_app_idx); 2779 2780 if (btif_hl_find_mcl_idx_using_app_idx(p_data->dch_open_ind.mcl_handle, orig_app_idx, &mcl_idx )) 2781 { 2782 p_acb =BTIF_HL_GET_APP_CB_PTR(orig_app_idx); 2783 p_mcb =BTIF_HL_GET_MCL_CB_PTR(orig_app_idx, mcl_idx); 2784 2785 if (btif_hl_find_avail_mdl_idx(orig_app_idx, mcl_idx, &mdl_idx)) 2786 { 2787 p_dcb = BTIF_HL_GET_MDL_CB_PTR(orig_app_idx, mcl_idx, mdl_idx); 2788 2789 if (btif_hl_find_mdep_cfg_idx(orig_app_idx, p_data->dch_open_ind.local_mdep_id, &mdep_cfg_idx)) 2790 { 2791 p_dcb->in_use = TRUE; 2792 p_dcb->mdl_handle = p_data->dch_open_ind.mdl_handle; 2793 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx; 2794 p_dcb->local_mdep_id = p_data->dch_open_ind.local_mdep_id; 2795 p_dcb->mdl_id = p_data->dch_open_ind.mdl_id; 2796 p_dcb->dch_mode = p_data->dch_open_ind.dch_mode; 2797 p_dcb->dch_mode = p_data->dch_open_ind.dch_mode; 2798 p_dcb->is_the_first_reliable = p_data->dch_open_ind.first_reliable; 2799 p_dcb->mtu = p_data->dch_open_ind.mtu; 2800 2801 if(btif_hl_find_channel_id_using_mdl_id(orig_app_idx,p_dcb->mdl_id , &p_dcb->channel_id)) 2802 { 2803 BTIF_TRACE_DEBUG(" app_idx=%d mcl_idx=%d mdl_idx=%d channel_id=%d", 2804 orig_app_idx, mcl_idx, mdl_idx, p_dcb->channel_id ); 2805 if (!btif_hl_create_socket(orig_app_idx, mcl_idx, mdl_idx)) 2806 { 2807 BTIF_TRACE_ERROR("Unable to create socket"); 2808 close_dch = TRUE; 2809 } 2810 } 2811 else 2812 { 2813 BTIF_TRACE_ERROR("Unable find channel id for mdl_id=0x%x", p_dcb->mdl_id ); 2814 close_dch = TRUE; 2815 } 2816 } 2817 else 2818 { 2819 BTIF_TRACE_ERROR("INVALID_LOCAL_MDEP_ID mdep_id=%d",p_data->dch_open_cfm.local_mdep_id); 2820 close_dch = TRUE; 2821 } 2822 2823 if (close_dch) 2824 btif_hl_clean_mdl_cb(p_dcb); 2825 } 2826 else 2827 close_dch = TRUE; 2828 } 2829 else 2830 close_dch = TRUE; 2831 2832 if (close_dch) 2833 BTA_HlDchClose(p_data->dch_open_cfm.mdl_handle); 2834} 2835 2836/******************************************************************************* 2837** 2838** Function btif_hl_proc_dch_open_cfm 2839** 2840** Description Process the DCH close confirmation 2841** 2842** Returns Nothing 2843** 2844*******************************************************************************/ 2845static BOOLEAN btif_hl_proc_dch_open_cfm(tBTA_HL *p_data) 2846 2847{ 2848 btif_hl_app_cb_t *p_acb; 2849 btif_hl_mcl_cb_t *p_mcb; 2850 btif_hl_mdl_cb_t *p_dcb; 2851 btif_hl_pending_chan_cb_t *p_pcb; 2852 UINT8 app_idx, mcl_idx, mdl_idx, mdep_cfg_idx; 2853 BOOLEAN status = FALSE; 2854 BOOLEAN close_dch = FALSE; 2855 2856 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 2857 2858 // Find the correct app_idx based on the mdep_id; 2859 btif_hl_find_app_idx_using_mdepId(p_data->dch_open_cfm.local_mdep_id,&app_idx); 2860 2861 if (btif_hl_find_mcl_idx_using_app_idx(p_data->dch_open_cfm.mcl_handle, app_idx, &mcl_idx )) 2862 { 2863 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 2864 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 2865 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx); 2866 2867 if (btif_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx)) 2868 { 2869 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); 2870 2871 if (btif_hl_find_mdep_cfg_idx(app_idx, p_data->dch_open_cfm.local_mdep_id, &mdep_cfg_idx)) 2872 { 2873 p_dcb->in_use = TRUE; 2874 p_dcb->mdl_handle = p_data->dch_open_cfm.mdl_handle; 2875 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx; 2876 p_dcb->local_mdep_id = p_data->dch_open_cfm.local_mdep_id; 2877 p_dcb->mdl_id = p_data->dch_open_cfm.mdl_id; 2878 p_dcb->dch_mode = p_data->dch_open_cfm.dch_mode; 2879 p_dcb->is_the_first_reliable= p_data->dch_open_cfm.first_reliable; 2880 p_dcb->mtu = p_data->dch_open_cfm.mtu; 2881 p_dcb->channel_id = p_pcb->channel_id; 2882 2883 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d mdl_idx=%d", app_idx, mcl_idx, mdl_idx ); 2884 btif_hl_send_setup_connecting_cb(app_idx, mcl_idx); 2885 if (btif_hl_create_socket(app_idx, mcl_idx, mdl_idx)) 2886 { 2887 status = TRUE; 2888 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d mdl_idx=%d p_dcb->channel_id=0x%08x", 2889 app_idx, mcl_idx, mdl_idx, p_dcb->channel_id); 2890 btif_hl_clean_pcb(p_pcb); 2891 } 2892 else 2893 { 2894 BTIF_TRACE_ERROR("Unable to create socket"); 2895 close_dch = TRUE; 2896 } 2897 } 2898 else 2899 { 2900 BTIF_TRACE_ERROR("INVALID_LOCAL_MDEP_ID mdep_id=%d",p_data->dch_open_cfm.local_mdep_id); 2901 close_dch = TRUE; 2902 } 2903 2904 if (close_dch) 2905 { 2906 btif_hl_clean_mdl_cb(p_dcb); 2907 BTA_HlDchClose(p_data->dch_open_cfm.mdl_handle); 2908 } 2909 } 2910 } 2911 2912 return status; 2913} 2914/******************************************************************************* 2915** 2916** Function btif_hl_proc_dch_reconnect_cfm 2917** 2918** Description Process the DCH reconnect indication 2919** 2920** Returns Nothing 2921** 2922*******************************************************************************/ 2923static BOOLEAN btif_hl_proc_dch_reconnect_cfm(tBTA_HL *p_data) 2924{ 2925 btif_hl_app_cb_t *p_acb; 2926 btif_hl_mcl_cb_t *p_mcb; 2927 btif_hl_mdl_cb_t *p_dcb; 2928 btif_hl_pending_chan_cb_t *p_pcb; 2929 UINT8 app_idx, mcl_idx, mdl_idx, mdep_cfg_idx; 2930 BOOLEAN status = FALSE; 2931 BOOLEAN close_dch = FALSE; 2932 2933 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 2934 2935 btif_hl_find_app_idx_using_mdepId(p_data->dch_reconnect_cfm.local_mdep_id,&app_idx); 2936 2937 if (btif_hl_find_mcl_idx_using_app_idx(p_data->dch_reconnect_cfm.mcl_handle, app_idx, &mcl_idx )) 2938 { 2939 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 2940 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 2941 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx); 2942 2943 if (btif_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx)) 2944 { 2945 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); 2946 2947 if (btif_hl_find_mdep_cfg_idx(app_idx, p_data->dch_reconnect_cfm.local_mdep_id, &mdep_cfg_idx)) 2948 { 2949 p_dcb->in_use = TRUE; 2950 p_dcb->mdl_handle = p_data->dch_reconnect_cfm.mdl_handle; 2951 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx; 2952 p_dcb->local_mdep_id = p_data->dch_reconnect_cfm.local_mdep_id; 2953 p_dcb->mdl_id = p_data->dch_reconnect_cfm.mdl_id; 2954 p_dcb->dch_mode = p_data->dch_reconnect_cfm.dch_mode; 2955 p_dcb->is_the_first_reliable= p_data->dch_reconnect_cfm.first_reliable; 2956 p_dcb->mtu = p_data->dch_reconnect_cfm.mtu; 2957 p_dcb->channel_id = p_pcb->channel_id; 2958 2959 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d mdl_idx=%d", app_idx, mcl_idx, mdl_idx ); 2960 btif_hl_send_setup_connecting_cb(app_idx, mcl_idx); 2961 if (btif_hl_create_socket(app_idx, mcl_idx, mdl_idx)) 2962 { 2963 status = TRUE; 2964 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d mdl_idx=%d p_dcb->channel_id=0x%08x", 2965 app_idx, mcl_idx, mdl_idx, p_dcb->channel_id); 2966 btif_hl_clean_pcb(p_pcb); 2967 } 2968 else 2969 { 2970 BTIF_TRACE_ERROR("Unable to create socket"); 2971 close_dch = TRUE; 2972 } 2973 } 2974 else 2975 { 2976 BTIF_TRACE_ERROR("INVALID_LOCAL_MDEP_ID mdep_id=%d",p_data->dch_open_cfm.local_mdep_id); 2977 close_dch = TRUE; 2978 } 2979 2980 if (close_dch) 2981 { 2982 btif_hl_clean_mdl_cb(p_dcb); 2983 BTA_HlDchClose(p_data->dch_reconnect_cfm.mdl_handle); 2984 } 2985 } 2986 } 2987 2988 return status; 2989 2990} 2991/******************************************************************************* 2992** 2993** Function btif_hl_proc_dch_reconnect_ind 2994** 2995** Description Process the DCH reconnect indication 2996** 2997** Returns Nothing 2998** 2999*******************************************************************************/ 3000static void btif_hl_proc_dch_reconnect_ind(tBTA_HL *p_data) 3001 3002{ 3003 btif_hl_app_cb_t *p_acb; 3004 btif_hl_mcl_cb_t *p_mcb; 3005 btif_hl_mdl_cb_t *p_dcb; 3006 UINT8 app_idx, mcl_idx, mdl_idx, mdep_cfg_idx, dc_cfg; 3007 BOOLEAN close_dch = FALSE; 3008 3009 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 3010 3011 // Find the correct app_idx based on the mdep_id; 3012 btif_hl_find_app_idx_using_mdepId(p_data->dch_reconnect_ind.local_mdep_id,&app_idx); 3013 3014 if (btif_hl_find_mcl_idx_using_app_idx(p_data->dch_reconnect_ind.mcl_handle, app_idx, &mcl_idx )) 3015 { 3016 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 3017 BTIF_TRACE_DEBUG("btif_hl_proc_dch_reconnect_ind: app_idx = %d, mcl_idx = %d", 3018 app_idx, mcl_idx); 3019 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 3020 3021 if (btif_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx)) 3022 { 3023 p_dcb =BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); 3024 3025 if (btif_hl_find_mdep_cfg_idx(app_idx, p_data->dch_reconnect_ind.local_mdep_id, &mdep_cfg_idx)) 3026 { 3027 p_dcb->in_use = TRUE; 3028 p_dcb->mdl_handle = p_data->dch_reconnect_ind.mdl_handle; 3029 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx; 3030 p_dcb->local_mdep_id = p_data->dch_reconnect_ind.local_mdep_id; 3031 p_dcb->mdl_id = p_data->dch_reconnect_ind.mdl_id; 3032 p_dcb->dch_mode = p_data->dch_reconnect_ind.dch_mode; 3033 p_dcb->dch_mode = p_data->dch_reconnect_ind.dch_mode; 3034 p_dcb->is_the_first_reliable= p_data->dch_reconnect_ind.first_reliable; 3035 p_dcb->mtu = p_data->dch_reconnect_ind.mtu; 3036 p_dcb->channel_id = btif_hl_get_next_channel_id(p_acb->app_id); 3037 3038 BTIF_TRACE_DEBUG(" app_idx=%d mcl_idx=%d mdl_idx=%d channel_id=%d", 3039 app_idx, mcl_idx, mdl_idx, p_dcb->channel_id ); 3040 if (!btif_hl_create_socket(app_idx, mcl_idx, mdl_idx)) 3041 { 3042 BTIF_TRACE_ERROR("Unable to create socket"); 3043 close_dch = TRUE; 3044 } 3045 } 3046 else 3047 { 3048 BTIF_TRACE_ERROR("INVALID_LOCAL_MDEP_ID mdep_id=%d",p_data->dch_open_cfm.local_mdep_id); 3049 close_dch = TRUE; 3050 } 3051 3052 if (close_dch) 3053 btif_hl_clean_mdl_cb(p_dcb); 3054 } 3055 else 3056 close_dch = TRUE; 3057 } 3058 else 3059 close_dch = TRUE; 3060 3061 if (close_dch) 3062 BTA_HlDchClose(p_data->dch_reconnect_ind.mdl_handle); 3063 3064} 3065 3066/******************************************************************************* 3067** 3068** Function btif_hl_proc_dch_close_ind 3069** 3070** Description Process the DCH close indication 3071** 3072** Returns Nothing 3073** 3074*******************************************************************************/ 3075static void btif_hl_proc_dch_close_ind(tBTA_HL *p_data) 3076 3077{ 3078 btif_hl_mdl_cb_t *p_dcb; 3079 btif_hl_mcl_cb_t *p_mcb; 3080 UINT8 app_idx, mcl_idx, mdl_idx; 3081 3082 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 3083 if (btif_hl_find_mdl_idx_using_handle(p_data->dch_close_ind.mdl_handle, 3084 &app_idx, &mcl_idx, &mdl_idx )) 3085 { 3086 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); 3087 btif_hl_release_socket(app_idx,mcl_idx, mdl_idx); 3088 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx); 3089 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx,mcl_idx); 3090 btif_hl_clean_mdl_cb(p_dcb); 3091 if (!btif_hl_num_dchs_in_use(p_mcb->mcl_handle)) 3092 btif_hl_start_cch_timer(app_idx, mcl_idx); 3093 BTIF_TRACE_DEBUG("remote DCH close success mdl_idx=%d", mdl_idx); 3094 } 3095} 3096 3097/******************************************************************************* 3098** 3099** Function btif_hl_proc_dch_close_cfm 3100** 3101** Description Process the DCH reconnect confirmation 3102** 3103** Returns Nothing 3104** 3105*******************************************************************************/ 3106static void btif_hl_proc_dch_close_cfm(tBTA_HL *p_data) 3107 3108{ 3109 btif_hl_mdl_cb_t *p_dcb; 3110 btif_hl_mcl_cb_t *p_mcb; 3111 UINT8 app_idx, mcl_idx, mdl_idx; 3112 3113 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 3114 if (btif_hl_find_mdl_idx_using_handle(p_data->dch_close_cfm.mdl_handle, 3115 &app_idx, &mcl_idx, &mdl_idx )) 3116 { 3117 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); 3118 btif_hl_release_socket(app_idx,mcl_idx,mdl_idx); 3119 btif_hl_clean_mdl_cb(p_dcb); 3120 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx,mcl_idx); 3121 if (!btif_hl_num_dchs_in_use(p_mcb->mcl_handle)) 3122 btif_hl_start_cch_timer(app_idx, mcl_idx); 3123 BTIF_TRACE_DEBUG(" local DCH close success mdl_idx=%d", mdl_idx); 3124 } 3125} 3126 3127 3128/******************************************************************************* 3129** 3130** Function btif_hl_proc_abort_ind 3131** 3132** Description Process the abort indicaiton 3133** 3134** Returns Nothing 3135** 3136*******************************************************************************/ 3137static void btif_hl_proc_abort_ind(tBTA_HL_MCL_HANDLE mcl_handle){ 3138 3139 UINT8 app_idx,mcl_idx; 3140 BTIF_TRACE_DEBUG("%s", __FUNCTION__ ); 3141 btif_hl_app_cb_t *p_acb; 3142 UINT8 i,j; 3143 3144 for (i=0; i<BTA_HL_NUM_APPS; i++) 3145 { 3146 p_acb =BTIF_HL_GET_APP_CB_PTR(i); 3147 for (j=0; j < BTA_HL_NUM_MCLS ; j++) 3148 { 3149 if (p_acb->mcb[j].in_use) 3150 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_handle: app_idx=%d,mcl_idx =%d mcl_handle=%d",i,j,p_acb->mcb[j].mcl_handle); 3151 if (p_acb->mcb[j].in_use && 3152 (p_acb->mcb[j].mcl_handle == mcl_handle)) 3153 { 3154 btif_hl_stop_cch_timer(i, j); 3155 btif_hl_send_setup_disconnected_cb(i, j); 3156 btif_hl_clean_mcl_cb(i, j); 3157 } 3158 } 3159 } 3160} 3161 3162/******************************************************************************* 3163** 3164** Function btif_hl_proc_abort_cfm 3165** 3166** Description Process the abort confirmation 3167** 3168** Returns Nothing 3169** 3170*******************************************************************************/ 3171static void btif_hl_proc_abort_cfm(tBTA_HL_MCL_HANDLE mcl_handle){ 3172 UINT8 app_idx,mcl_idx; 3173 3174 BTIF_TRACE_DEBUG("%s", __FUNCTION__ ); 3175 btif_hl_app_cb_t *p_acb; 3176 UINT8 i,j; 3177 3178 for (i=0; i<BTA_HL_NUM_APPS; i++) 3179 { 3180 p_acb =BTIF_HL_GET_APP_CB_PTR(i); 3181 for (j=0; j < BTA_HL_NUM_MCLS ; j++) 3182 { 3183 if (p_acb->mcb[j].in_use) 3184 BTIF_TRACE_DEBUG("btif_hl_find_mcl_idx_using_handle: app_idx=%d,mcl_idx =%d mcl_handle=%d",i,j,p_acb->mcb[j].mcl_handle); 3185 if (p_acb->mcb[j].in_use && 3186 (p_acb->mcb[j].mcl_handle == mcl_handle)) 3187 { 3188 btif_hl_stop_cch_timer(i, j); 3189 btif_hl_send_setup_disconnected_cb(i, j); 3190 btif_hl_clean_mcl_cb(i, j); 3191 } 3192 } 3193 } 3194 3195} 3196 3197/******************************************************************************* 3198** 3199** Function btif_hl_proc_send_data_cfm 3200** 3201** Description Process the send data confirmation 3202** 3203** Returns Nothing 3204** 3205*******************************************************************************/ 3206static void btif_hl_proc_send_data_cfm(tBTA_HL_MDL_HANDLE mdl_handle, 3207 tBTA_HL_STATUS status){ 3208 UINT8 app_idx,mcl_idx, mdl_idx; 3209 btif_hl_mdl_cb_t *p_dcb; 3210 UNUSED(status); 3211 3212 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 3213 if (btif_hl_find_mdl_idx_using_handle(mdl_handle, 3214 &app_idx, &mcl_idx, &mdl_idx )) 3215 { 3216 p_dcb =BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); 3217 btif_hl_free_buf((void **) &p_dcb->p_tx_pkt); 3218 BTIF_TRACE_DEBUG("send success free p_tx_pkt tx_size=%d", p_dcb->tx_size); 3219 p_dcb->tx_size = 0; 3220 } 3221} 3222 3223/******************************************************************************* 3224** 3225** Function btif_hl_proc_dch_cong_ind 3226** 3227** Description Process the DCH congestion change indication 3228** 3229** Returns Nothing 3230** 3231*******************************************************************************/ 3232static void btif_hl_proc_dch_cong_ind(tBTA_HL *p_data) 3233 3234{ 3235 btif_hl_mdl_cb_t *p_dcb; 3236 UINT8 app_idx, mcl_idx, mdl_idx; 3237 3238 BTIF_TRACE_DEBUG("btif_hl_proc_dch_cong_ind"); 3239 3240 3241 if (btif_hl_find_mdl_idx_using_handle(p_data->dch_cong_ind.mdl_handle, &app_idx, &mcl_idx, &mdl_idx)) 3242 { 3243 p_dcb =BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); 3244 p_dcb->cong = p_data->dch_cong_ind.cong; 3245 } 3246} 3247 3248/******************************************************************************* 3249** 3250** Function btif_hl_proc_reg_request 3251** 3252** Description Process registration request 3253** 3254** Returns void 3255** 3256*******************************************************************************/ 3257static void btif_hl_proc_reg_request(UINT8 app_idx, UINT8 app_id, 3258 tBTA_HL_REG_PARAM *p_reg_param, 3259 tBTA_HL_CBACK *p_cback){ 3260 bt_status_t status= BT_STATUS_SUCCESS; 3261 UINT8 i; 3262 btif_hl_app_data_t *p_data; 3263 UNUSED(p_cback); 3264 3265 BTIF_TRACE_DEBUG("%s app_idx=%d app_id=%d", __FUNCTION__, app_idx, app_id); 3266 3267 if(reg_counter >1) 3268 { 3269 BTIF_TRACE_DEBUG("btif_hl_proc_reg_request: calling uPDATE"); 3270 BTA_HlUpdate(app_id, p_reg_param,TRUE, btif_hl_cback); 3271 } 3272 else 3273 BTA_HlRegister(app_id, p_reg_param, btif_hl_cback); 3274} 3275 3276 3277/******************************************************************************* 3278** 3279** Function btif_hl_proc_cb_evt 3280** 3281** Description Process HL callback events 3282** 3283** Returns void 3284** 3285*******************************************************************************/ 3286static void btif_hl_proc_cb_evt(UINT16 event, char* p_param){ 3287 3288 btif_hl_evt_cb_t *p_data = (btif_hl_evt_cb_t *)p_param; 3289 bt_bdaddr_t bd_addr; 3290 bthl_channel_state_t state=BTHL_CONN_STATE_DISCONNECTED; 3291 BOOLEAN send_chan_cb=TRUE; 3292 tBTA_HL_REG_PARAM reg_param; 3293 btif_hl_app_cb_t *p_acb; 3294 bthl_app_reg_state_t reg_state = BTHL_APP_REG_STATE_REG_FAILED; 3295 int app_id; 3296 UINT8 preg_idx; 3297 bt_status_t bt_status; 3298 3299 BTIF_TRACE_DEBUG("%s event %d", __FUNCTION__, event); 3300 btif_hl_display_calling_process_name(); 3301 3302 switch (event) 3303 { 3304 case BTIF_HL_SEND_CONNECTED_CB: 3305 case BTIF_HL_SEND_DISCONNECTED_CB: 3306 if (p_data->chan_cb.cb_state == BTIF_HL_CHAN_CB_STATE_CONNECTED_PENDING) 3307 state = BTHL_CONN_STATE_CONNECTED; 3308 else if (p_data->chan_cb.cb_state == BTIF_HL_CHAN_CB_STATE_DISCONNECTED_PENDING) 3309 state = BTHL_CONN_STATE_DISCONNECTED; 3310 else 3311 send_chan_cb = FALSE; 3312 3313 if (send_chan_cb) 3314 { 3315 btif_hl_copy_bda(&bd_addr, p_data->chan_cb.bd_addr); 3316 BTIF_TRACE_DEBUG("state callbk: ch_id=0x%08x cb_state=%d state=%d fd=%d", 3317 p_data->chan_cb.channel_id, 3318 p_data->chan_cb.cb_state, 3319 state, p_data->chan_cb.fd); 3320 btif_hl_display_bt_bda(&bd_addr); 3321 BTIF_HL_CALL_CBACK(bt_hl_callbacks, channel_state_cb, p_data->chan_cb.app_id, 3322 &bd_addr, p_data->chan_cb.mdep_cfg_index, 3323 p_data->chan_cb.channel_id, state, p_data->chan_cb.fd ); 3324 } 3325 3326 break; 3327 case BTIF_HL_REG_APP: 3328 p_acb = BTIF_HL_GET_APP_CB_PTR(p_data->reg.app_idx); 3329 app_id = (int) p_acb->app_id; 3330 BTIF_TRACE_DEBUG("Rcv BTIF_HL_REG_APP app_idx=%d reg_pending=%d", p_data->reg.app_idx, p_acb->reg_pending); 3331 if (btif_hl_get_state() == BTIF_HL_STATE_ENABLED && p_acb->reg_pending) 3332 { 3333 BTIF_TRACE_DEBUG("Rcv BTIF_HL_REG_APP reg_counter=%d",reg_counter); 3334 p_acb->reg_pending = FALSE; 3335 reg_param.dev_type = p_acb->dev_type; 3336 reg_param.sec_mask = BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT; 3337 reg_param.p_srv_name = p_acb->srv_name; 3338 reg_param.p_srv_desp = p_acb->srv_desp; 3339 reg_param.p_provider_name = p_acb->provider_name; 3340 btif_hl_proc_reg_request (p_data->reg.app_idx, p_acb->app_id, ®_param, btif_hl_cback); 3341 } 3342 else 3343 { 3344 BTIF_TRACE_DEBUG("reg request is processed state=%d reg_pending=%d", btif_hl_get_state(), p_acb->reg_pending); 3345 } 3346 3347 break; 3348 3349 case BTIF_HL_UNREG_APP: 3350 BTIF_TRACE_DEBUG("Rcv BTIF_HL_UNREG_APP app_idx=%d", p_data->unreg.app_idx ); 3351 p_acb = BTIF_HL_GET_APP_CB_PTR(p_data->unreg.app_idx); 3352 if (btif_hl_get_state() == BTIF_HL_STATE_ENABLED) 3353 { 3354 if(reg_counter >= 1) 3355 BTA_HlUpdate(p_acb->app_id,NULL,FALSE,NULL); 3356 else 3357 BTA_HlDeregister(p_acb->app_id, p_acb->app_handle); 3358 } 3359 break; 3360 case BTIF_HL_UPDATE_MDL: 3361 BTIF_TRACE_DEBUG("Rcv BTIF_HL_UPDATE_MDL app_idx=%d", p_data->update_mdl.app_idx ); 3362 p_acb = BTIF_HL_GET_APP_CB_PTR(p_data->update_mdl.app_idx); 3363 break; 3364 3365 default: 3366 BTIF_TRACE_ERROR("Unknown event %d", event); 3367 break; 3368 } 3369} 3370 3371/******************************************************************************* 3372** 3373** Function btif_hl_upstreams_evt 3374** 3375** Description Process HL events 3376** 3377** Returns void 3378** 3379*******************************************************************************/ 3380static void btif_hl_upstreams_evt(UINT16 event, char* p_param){ 3381 tBTA_HL *p_data = (tBTA_HL *)p_param; 3382 UINT8 app_idx, mcl_idx; 3383 btif_hl_app_cb_t *p_acb; 3384 btif_hl_mcl_cb_t *p_mcb = NULL; 3385 BD_ADDR bd_addr; 3386 btif_hl_pend_dch_op_t pending_op; 3387 BOOLEAN status; 3388 3389 BTIF_TRACE_DEBUG("%s event %d", __FUNCTION__, event); 3390 btif_hl_display_calling_process_name(); 3391 switch (event) 3392 { 3393 case BTA_HL_REGISTER_CFM_EVT: 3394 BTIF_TRACE_DEBUG("Rcv BTA_HL_REGISTER_CFM_EVT"); 3395 BTIF_TRACE_DEBUG("app_id=%d app_handle=%d status=%d ", 3396 p_data->reg_cfm.app_id, 3397 p_data->reg_cfm.app_handle, 3398 p_data->reg_cfm.status ); 3399 3400 btif_hl_proc_reg_cfm(p_data); 3401 break; 3402 case BTA_HL_SDP_INFO_IND_EVT: 3403 BTIF_TRACE_DEBUG("Rcv BTA_HL_SDP_INFO_IND_EVT"); 3404 BTIF_TRACE_DEBUG("app_handle=%d ctrl_psm=0x%04x data_psm=0x%04x x_spec=%d mcap_sup_procs=0x%02x", 3405 p_data->sdp_info_ind.app_handle, 3406 p_data->sdp_info_ind.ctrl_psm, 3407 p_data->sdp_info_ind.data_psm, 3408 p_data->sdp_info_ind.data_x_spec, 3409 p_data->sdp_info_ind.mcap_sup_procs); 3410 //btif_hl_proc_sdp_info_ind(p_data); 3411 break; 3412 3413 case BTA_HL_DEREGISTER_CFM_EVT: 3414 BTIF_TRACE_DEBUG("Rcv BTA_HL_DEREGISTER_CFM_EVT"); 3415 BTIF_TRACE_DEBUG("app_handle=%d status=%d ", 3416 p_data->dereg_cfm.app_handle, 3417 p_data->dereg_cfm.status ); 3418 btif_hl_proc_dereg_cfm(p_data); 3419 break; 3420 3421 case BTA_HL_SDP_QUERY_CFM_EVT: 3422 BTIF_TRACE_DEBUG("Rcv BTA_HL_SDP_QUERY_CFM_EVT"); 3423 BTIF_TRACE_DEBUG("app_handle=%d app_id =%d,status =%d", 3424 p_data->sdp_query_cfm.app_handle,p_data->sdp_query_cfm.app_id, 3425 p_data->sdp_query_cfm.status); 3426 3427 BTIF_TRACE_DEBUG("DB [%02x] [%02x] [%02x] [%02x] [%02x] [%02x]", 3428 p_data->sdp_query_cfm.bd_addr[0], p_data->sdp_query_cfm.bd_addr[1], 3429 p_data->sdp_query_cfm.bd_addr[2], p_data->sdp_query_cfm.bd_addr[3], 3430 p_data->sdp_query_cfm.bd_addr[4], p_data->sdp_query_cfm.bd_addr[5]); 3431 3432 if (p_data->sdp_query_cfm.status == BTA_HL_STATUS_OK) 3433 status = btif_hl_proc_sdp_query_cfm(p_data); 3434 else 3435 status = FALSE; 3436 3437 if (!status) 3438 { 3439 BTIF_TRACE_DEBUG("BTA_HL_SDP_QUERY_CFM_EVT Status = %d", 3440 p_data->sdp_query_cfm.status); 3441 if (btif_hl_find_app_idx_using_app_id(p_data->sdp_query_cfm.app_id, &app_idx)) 3442 { 3443 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 3444 if (btif_hl_find_mcl_idx(app_idx, p_data->sdp_query_cfm.bd_addr, &mcl_idx)) 3445 { 3446 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 3447 if ( (p_mcb->cch_oper == BTIF_HL_CCH_OP_MDEP_FILTERING) || 3448 (p_mcb->cch_oper == BTIF_HL_CCH_OP_DCH_OPEN) ) 3449 { 3450 pending_op = p_mcb->pcb.op; 3451 switch (pending_op) 3452 { 3453 case BTIF_HL_PEND_DCH_OP_OPEN: 3454 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx); 3455 break; 3456 case BTIF_HL_PEND_DCH_OP_RECONNECT: 3457 case BTIF_HL_PEND_DCH_OP_DELETE_MDL: 3458 default: 3459 break; 3460 } 3461 if (!p_mcb->is_connected) 3462 btif_hl_clean_mcl_cb(app_idx, mcl_idx); 3463 } 3464 } 3465 } 3466 } 3467 3468 break; 3469 3470 3471 case BTA_HL_CCH_OPEN_CFM_EVT: 3472 BTIF_TRACE_DEBUG("Rcv BTA_HL_CCH_OPEN_CFM_EVT"); 3473 BTIF_TRACE_DEBUG("app_id=%d,app_handle=%d mcl_handle=%d status =%d", 3474 p_data->cch_open_cfm.app_id, 3475 p_data->cch_open_cfm.app_handle, 3476 p_data->cch_open_cfm.mcl_handle, 3477 p_data->cch_open_cfm.status); 3478 BTIF_TRACE_DEBUG("DB [%02x] [%02x] [%02x] [%02x] [%02x] [%02x]", 3479 p_data->cch_open_cfm.bd_addr[0], p_data->cch_open_cfm.bd_addr[1], 3480 p_data->cch_open_cfm.bd_addr[2], p_data->cch_open_cfm.bd_addr[3], 3481 p_data->cch_open_cfm.bd_addr[4], p_data->cch_open_cfm.bd_addr[5]); 3482 3483 if (p_data->cch_open_cfm.status == BTA_HL_STATUS_OK || 3484 p_data->cch_open_cfm.status == BTA_HL_STATUS_DUPLICATE_CCH_OPEN) 3485 { 3486 status = btif_hl_proc_cch_open_cfm(p_data); 3487 } 3488 else 3489 { 3490 status = FALSE; 3491 } 3492 3493 if (!status) 3494 { 3495 if (btif_hl_find_app_idx_using_app_id(p_data->cch_open_cfm.app_id, &app_idx)) 3496 { 3497 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 3498 if (btif_hl_find_mcl_idx(app_idx, p_data->cch_open_cfm.bd_addr, &mcl_idx)) 3499 { 3500 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 3501 pending_op = p_mcb->pcb.op; 3502 switch (pending_op) 3503 { 3504 case BTIF_HL_PEND_DCH_OP_OPEN: 3505 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx); 3506 break; 3507 case BTIF_HL_PEND_DCH_OP_RECONNECT: 3508 case BTIF_HL_PEND_DCH_OP_DELETE_MDL: 3509 default: 3510 break; 3511 } 3512 btif_hl_clean_mcl_cb(app_idx, mcl_idx); 3513 } 3514 } 3515 } 3516 break; 3517 3518 case BTA_HL_DCH_OPEN_CFM_EVT: 3519 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_OPEN_CFM_EVT"); 3520 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_handle=0x%x status=%d ", 3521 p_data->dch_open_cfm.mcl_handle, 3522 p_data->dch_open_cfm.mdl_handle, 3523 p_data->dch_open_cfm.status); 3524 BTIF_TRACE_DEBUG("first_reliable =%d dch_mode=%d local_mdep_id=%d mdl_id=%d mtu=%d", 3525 p_data->dch_open_cfm.first_reliable, 3526 p_data->dch_open_cfm.dch_mode, 3527 p_data->dch_open_cfm.local_mdep_id, 3528 p_data->dch_open_cfm.mdl_id, 3529 p_data->dch_open_cfm.mtu); 3530 if (p_data->dch_open_cfm.status == BTA_HL_STATUS_OK) 3531 { 3532 status = btif_hl_proc_dch_open_cfm(p_data); 3533 } 3534 else 3535 { 3536 status = FALSE; 3537 } 3538 3539 if (!status) 3540 { 3541 if (btif_hl_find_mcl_idx_using_handle(p_data->dch_open_cfm.mcl_handle,&app_idx, &mcl_idx)) 3542 { 3543 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 3544 pending_op = p_mcb->pcb.op; 3545 switch (pending_op) 3546 { 3547 case BTIF_HL_PEND_DCH_OP_OPEN: 3548 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx); 3549 break; 3550 case BTIF_HL_PEND_DCH_OP_RECONNECT: 3551 case BTIF_HL_PEND_DCH_OP_DELETE_MDL: 3552 default: 3553 break; 3554 } 3555 } 3556 } 3557 break; 3558 3559 3560 case BTA_HL_CCH_OPEN_IND_EVT: 3561 BTIF_TRACE_DEBUG("Rcv BTA_HL_CCH_OPEN_IND_EVT"); 3562 BTIF_TRACE_DEBUG("app_handle=%d mcl_handle=%d", 3563 p_data->cch_open_ind.app_handle, 3564 p_data->cch_open_ind.mcl_handle); 3565 BTIF_TRACE_DEBUG("DB [%02x] [%02x] [%02x] [%02x] [%02x] [%02x]", 3566 p_data->cch_open_ind.bd_addr[0], p_data->cch_open_ind.bd_addr[1], 3567 p_data->cch_open_ind.bd_addr[2], p_data->cch_open_ind.bd_addr[3], 3568 p_data->cch_open_ind.bd_addr[4], p_data->cch_open_ind.bd_addr[5]); 3569 3570 btif_hl_proc_cch_open_ind(p_data); 3571 break; 3572 3573 case BTA_HL_DCH_CREATE_IND_EVT: 3574 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_CREATE_IND_EVT"); 3575 BTIF_TRACE_DEBUG("mcl_handle=%d", 3576 p_data->dch_create_ind.mcl_handle ); 3577 BTIF_TRACE_DEBUG("local_mdep_id =%d mdl_id=%d cfg=%d", 3578 p_data->dch_create_ind.local_mdep_id, 3579 p_data->dch_create_ind.mdl_id, 3580 p_data->dch_create_ind.cfg); 3581 btif_hl_proc_create_ind(p_data); 3582 break; 3583 3584 case BTA_HL_DCH_OPEN_IND_EVT: 3585 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_OPEN_IND_EVT"); 3586 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_handle=0x%x", 3587 p_data->dch_open_ind.mcl_handle, 3588 p_data->dch_open_ind.mdl_handle ); 3589 BTIF_TRACE_DEBUG("first_reliable =%d dch_mode=%d local_mdep_id=%d mdl_id=%d mtu=%d", 3590 p_data->dch_open_ind.first_reliable, 3591 p_data->dch_open_ind.dch_mode, 3592 p_data->dch_open_ind.local_mdep_id, 3593 p_data->dch_open_ind.mdl_id, 3594 p_data->dch_open_ind.mtu); 3595 3596 btif_hl_proc_dch_open_ind(p_data); 3597 break; 3598 3599 case BTA_HL_DELETE_MDL_IND_EVT: 3600 BTIF_TRACE_DEBUG("Rcv BTA_HL_DELETE_MDL_IND_EVT"); 3601 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_id=0x%x", 3602 p_data->delete_mdl_ind.mcl_handle, 3603 p_data->delete_mdl_ind.mdl_id); 3604 break; 3605 3606 case BTA_HL_DELETE_MDL_CFM_EVT: 3607 BTIF_TRACE_DEBUG("Rcv BTA_HL_DELETE_MDL_CFM_EVT"); 3608 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_id=0x%x status=%d", 3609 p_data->delete_mdl_cfm.mcl_handle, 3610 p_data->delete_mdl_cfm.mdl_id, 3611 p_data->delete_mdl_cfm.status); 3612 3613 if (btif_hl_find_app_idx_using_deleted_mdl_id( p_data->delete_mdl_cfm.mdl_id, 3614 &app_idx)) 3615 { 3616 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 3617 btif_hl_send_destroyed_cb(p_acb); 3618 btif_hl_clean_delete_mdl(&p_acb->delete_mdl); 3619 } 3620 break; 3621 3622 case BTA_HL_DCH_RECONNECT_CFM_EVT: 3623 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_RECONNECT_CFM_EVT"); 3624 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_handle=%d status=%d ", 3625 p_data->dch_reconnect_cfm.mcl_handle, 3626 p_data->dch_reconnect_cfm.mdl_handle, 3627 p_data->dch_reconnect_cfm.status); 3628 BTIF_TRACE_DEBUG("first_reliable =%d dch_mode=%d mdl_id=%d mtu=%d", 3629 p_data->dch_reconnect_cfm.first_reliable, 3630 p_data->dch_reconnect_cfm.dch_mode, 3631 p_data->dch_reconnect_cfm.mdl_id, 3632 p_data->dch_reconnect_cfm.mtu); 3633 3634 3635 if (p_data->dch_reconnect_cfm.status == BTA_HL_STATUS_OK) 3636 { 3637 status = btif_hl_proc_dch_reconnect_cfm(p_data); 3638 } 3639 else 3640 { 3641 status = FALSE; 3642 } 3643 3644 if (!status) 3645 { 3646 if (btif_hl_find_mcl_idx_using_handle(p_data->dch_open_cfm.mcl_handle,&app_idx, &mcl_idx)) 3647 { 3648 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 3649 pending_op = p_mcb->pcb.op; 3650 switch (pending_op) 3651 { 3652 case BTIF_HL_PEND_DCH_OP_OPEN: 3653 btif_hl_send_setup_disconnected_cb(app_idx, mcl_idx); 3654 break; 3655 case BTIF_HL_PEND_DCH_OP_RECONNECT: 3656 case BTIF_HL_PEND_DCH_OP_DELETE_MDL: 3657 default: 3658 break; 3659 } 3660 } 3661 } 3662 3663 break; 3664 3665 case BTA_HL_CCH_CLOSE_CFM_EVT: 3666 BTIF_TRACE_DEBUG("Rcv BTA_HL_CCH_CLOSE_CFM_EVT"); 3667 BTIF_TRACE_DEBUG("mcl_handle=%d status =%d", 3668 p_data->cch_close_cfm.mcl_handle, 3669 p_data->cch_close_cfm.status); 3670 if (p_data->cch_close_cfm.status == BTA_HL_STATUS_OK) 3671 { 3672 btif_hl_proc_cch_close_cfm(p_data); 3673 } 3674 break; 3675 3676 case BTA_HL_CCH_CLOSE_IND_EVT: 3677 BTIF_TRACE_DEBUG("Rcv BTA_HL_CCH_CLOSE_IND_EVT"); 3678 BTIF_TRACE_DEBUG("mcl_handle =%d intentional_close=%s", 3679 p_data->cch_close_ind.mcl_handle, 3680 (p_data->cch_close_ind.intentional?"Yes":"No")); 3681 3682 btif_hl_proc_cch_close_ind(p_data); 3683 break; 3684 3685 case BTA_HL_DCH_CLOSE_IND_EVT: 3686 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_CLOSE_IND_EVT"); 3687 BTIF_TRACE_DEBUG("mdl_handle=%d intentional_close=%s", 3688 p_data->dch_close_ind.mdl_handle, 3689 (p_data->dch_close_ind.intentional?"Yes":"No") ); 3690 3691 btif_hl_proc_dch_close_ind(p_data); 3692 break; 3693 3694 case BTA_HL_DCH_CLOSE_CFM_EVT: 3695 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_CLOSE_CFM_EVT"); 3696 BTIF_TRACE_DEBUG("mdl_handle=%d status=%d ", 3697 p_data->dch_close_cfm.mdl_handle, 3698 p_data->dch_close_cfm.status); 3699 3700 if (p_data->dch_close_cfm.status == BTA_HL_STATUS_OK) 3701 { 3702 btif_hl_proc_dch_close_cfm(p_data); 3703 } 3704 break; 3705 3706 case BTA_HL_DCH_ECHO_TEST_CFM_EVT: 3707 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_ECHO_TEST_CFM_EVT"); 3708 BTIF_TRACE_DEBUG("mcl_handle=%d status=%d", 3709 p_data->echo_test_cfm.mcl_handle, 3710 p_data->echo_test_cfm.status ); 3711 /* not supported */ 3712 break; 3713 3714 3715 case BTA_HL_DCH_RECONNECT_IND_EVT: 3716 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_RECONNECT_IND_EVT"); 3717 3718 BTIF_TRACE_DEBUG("mcl_handle=%d mdl_handle=5d", 3719 p_data->dch_reconnect_ind.mcl_handle, 3720 p_data->dch_reconnect_ind.mdl_handle ); 3721 BTIF_TRACE_DEBUG("first_reliable =%d dch_mode=%d mdl_id=%d mtu=%d", 3722 p_data->dch_reconnect_ind.first_reliable, 3723 p_data->dch_reconnect_ind.dch_mode, 3724 p_data->dch_reconnect_ind.mdl_id, 3725 p_data->dch_reconnect_ind.mtu); 3726 3727 btif_hl_proc_dch_reconnect_ind(p_data); 3728 break; 3729 3730 case BTA_HL_CONG_CHG_IND_EVT: 3731 BTIF_TRACE_DEBUG("Rcv BTA_HL_CONG_CHG_IND_EVT"); 3732 BTIF_TRACE_DEBUG("mdl_handle=%d cong =%d", 3733 p_data->dch_cong_ind.mdl_handle, 3734 p_data->dch_cong_ind.cong); 3735 btif_hl_proc_dch_cong_ind(p_data); 3736 break; 3737 3738 case BTA_HL_DCH_ABORT_IND_EVT: 3739 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_ABORT_IND_EVT"); 3740 BTIF_TRACE_DEBUG("mcl_handle=%d", 3741 p_data->dch_abort_ind.mcl_handle ); 3742 btif_hl_proc_abort_ind(p_data->dch_abort_ind.mcl_handle); 3743 break; 3744 case BTA_HL_DCH_ABORT_CFM_EVT: 3745 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_ABORT_CFM_EVT"); 3746 BTIF_TRACE_DEBUG("mcl_handle=%d status =%d", 3747 p_data->dch_abort_cfm.mcl_handle, 3748 p_data->dch_abort_cfm.status); 3749 if (p_data->dch_abort_cfm.status == BTA_HL_STATUS_OK) 3750 { 3751 btif_hl_proc_abort_cfm(p_data->dch_abort_ind.mcl_handle); 3752 } 3753 break; 3754 3755 case BTA_HL_DCH_SEND_DATA_CFM_EVT: 3756 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_SEND_DATA_CFM_EVT"); 3757 BTIF_TRACE_DEBUG("mdl_handle=0x%x status =%d", 3758 p_data->dch_send_data_cfm.mdl_handle, 3759 p_data->dch_send_data_cfm.status); 3760 btif_hl_proc_send_data_cfm(p_data->dch_send_data_cfm.mdl_handle, 3761 p_data->dch_send_data_cfm.status); 3762 break; 3763 3764 case BTA_HL_DCH_RCV_DATA_IND_EVT: 3765 BTIF_TRACE_DEBUG("Rcv BTA_HL_DCH_RCV_DATA_IND_EVT"); 3766 BTIF_TRACE_DEBUG("mdl_handle=0x%x ", 3767 p_data->dch_rcv_data_ind.mdl_handle); 3768 /* do nothing here */ 3769 break; 3770 3771 default: 3772 BTIF_TRACE_DEBUG("Unknown Event (0x%02x)...", event); 3773 break; 3774 } 3775} 3776 3777/******************************************************************************* 3778** 3779** Function btif_hl_cback 3780** 3781** Description Callback function for HL events 3782** 3783** Returns void 3784** 3785*******************************************************************************/ 3786static void btif_hl_cback(tBTA_HL_EVT event, tBTA_HL *p_data){ 3787 bt_status_t status; 3788 int param_len = 0; 3789 BTIF_TRACE_DEBUG("%s event %d", __FUNCTION__, event); 3790 btif_hl_display_calling_process_name(); 3791 switch (event) 3792 { 3793 case BTA_HL_REGISTER_CFM_EVT: 3794 param_len = sizeof(tBTA_HL_REGISTER_CFM); 3795 break; 3796 case BTA_HL_SDP_INFO_IND_EVT: 3797 param_len = sizeof(tBTA_HL_SDP_INFO_IND); 3798 break; 3799 case BTA_HL_DEREGISTER_CFM_EVT: 3800 param_len = sizeof(tBTA_HL_DEREGISTER_CFM); 3801 break; 3802 case BTA_HL_SDP_QUERY_CFM_EVT: 3803 param_len = sizeof(tBTA_HL_SDP_QUERY_CFM); 3804 break; 3805 case BTA_HL_CCH_OPEN_CFM_EVT: 3806 param_len = sizeof(tBTA_HL_CCH_OPEN_CFM); 3807 break; 3808 case BTA_HL_DCH_OPEN_CFM_EVT: 3809 param_len = sizeof(tBTA_HL_DCH_OPEN_CFM); 3810 break; 3811 case BTA_HL_CCH_OPEN_IND_EVT: 3812 param_len = sizeof(tBTA_HL_CCH_OPEN_IND); 3813 break; 3814 case BTA_HL_DCH_CREATE_IND_EVT: 3815 param_len = sizeof(tBTA_HL_DCH_CREATE_IND); 3816 break; 3817 case BTA_HL_DCH_OPEN_IND_EVT: 3818 param_len = sizeof(tBTA_HL_DCH_OPEN_IND); 3819 break; 3820 case BTA_HL_DELETE_MDL_IND_EVT: 3821 param_len = sizeof(tBTA_HL_MDL_IND); 3822 break; 3823 case BTA_HL_DELETE_MDL_CFM_EVT: 3824 param_len = sizeof(tBTA_HL_MDL_CFM); 3825 break; 3826 case BTA_HL_DCH_RECONNECT_CFM_EVT: 3827 param_len = sizeof(tBTA_HL_DCH_OPEN_CFM); 3828 break; 3829 case BTA_HL_CCH_CLOSE_CFM_EVT: 3830 param_len = sizeof(tBTA_HL_MCL_CFM); 3831 break; 3832 case BTA_HL_CCH_CLOSE_IND_EVT: 3833 param_len = sizeof(tBTA_HL_CCH_CLOSE_IND); 3834 break; 3835 case BTA_HL_DCH_CLOSE_IND_EVT: 3836 param_len = sizeof(tBTA_HL_DCH_CLOSE_IND); 3837 break; 3838 case BTA_HL_DCH_CLOSE_CFM_EVT: 3839 param_len = sizeof(tBTA_HL_MDL_CFM); 3840 break; 3841 case BTA_HL_DCH_ECHO_TEST_CFM_EVT: 3842 param_len = sizeof(tBTA_HL_MCL_CFM); 3843 break; 3844 case BTA_HL_DCH_RECONNECT_IND_EVT: 3845 param_len = sizeof(tBTA_HL_DCH_OPEN_IND); 3846 break; 3847 case BTA_HL_CONG_CHG_IND_EVT: 3848 param_len = sizeof(tBTA_HL_DCH_CONG_IND); 3849 break; 3850 case BTA_HL_DCH_ABORT_IND_EVT: 3851 param_len = sizeof(tBTA_HL_MCL_IND); 3852 break; 3853 case BTA_HL_DCH_ABORT_CFM_EVT: 3854 param_len = sizeof(tBTA_HL_MCL_CFM); 3855 break; 3856 case BTA_HL_DCH_SEND_DATA_CFM_EVT: 3857 param_len = sizeof(tBTA_HL_MDL_CFM); 3858 break; 3859 case BTA_HL_DCH_RCV_DATA_IND_EVT: 3860 param_len = sizeof(tBTA_HL_MDL_IND); 3861 break; 3862 default: 3863 param_len = sizeof(tBTA_HL_MDL_IND); 3864 break; 3865 } 3866 status = btif_transfer_context(btif_hl_upstreams_evt, (uint16_t)event, (void*)p_data, param_len, NULL); 3867 3868 /* catch any failed context transfers */ 3869 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status); 3870} 3871 3872/******************************************************************************* 3873** 3874** Function btif_hl_upstreams_ctrl_evt 3875** 3876** Description Callback function for HL control events in the BTIF task context 3877** 3878** Returns void 3879** 3880*******************************************************************************/ 3881static void btif_hl_upstreams_ctrl_evt(UINT16 event, char* p_param){ 3882 tBTA_HL_CTRL *p_data = (tBTA_HL_CTRL *) p_param; 3883 UINT8 i; 3884 tBTA_HL_REG_PARAM reg_param; 3885 btif_hl_app_cb_t *p_acb; 3886 3887 BTIF_TRACE_DEBUG("%s event %d", __FUNCTION__, event); 3888 btif_hl_display_calling_process_name(); 3889 3890 switch ( event ) 3891 { 3892 case BTA_HL_CTRL_ENABLE_CFM_EVT: 3893 BTIF_TRACE_DEBUG("Rcv BTA_HL_CTRL_ENABLE_CFM_EVT"); 3894 BTIF_TRACE_DEBUG("status=%d", p_data->enable_cfm.status); 3895 3896 if (p_data->enable_cfm.status == BTA_HL_STATUS_OK) 3897 { 3898 btif_hl_set_state(BTIF_HL_STATE_ENABLED); 3899 3900 3901 for (i=0; i < BTA_HL_NUM_APPS ; i ++) 3902 { 3903 p_acb = BTIF_HL_GET_APP_CB_PTR(i); 3904 if (p_acb->in_use && p_acb->reg_pending) 3905 { 3906 p_acb->reg_pending = FALSE; 3907 reg_param.dev_type = p_acb->dev_type; 3908 reg_param.sec_mask = BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT; 3909 reg_param.p_srv_name = p_acb->srv_name; 3910 reg_param.p_srv_desp = p_acb->srv_desp; 3911 reg_param.p_provider_name = p_acb->provider_name; 3912 3913 BTIF_TRACE_DEBUG("Register pending app_id=%d", p_acb->app_id); 3914 btif_hl_proc_reg_request (i, p_acb->app_id, ®_param, btif_hl_cback); 3915 } 3916 } 3917 } 3918 3919 break; 3920 case BTA_HL_CTRL_DISABLE_CFM_EVT: 3921 BTIF_TRACE_DEBUG("Rcv BTA_HL_CTRL_DISABLE_CFM_EVT"); 3922 BTIF_TRACE_DEBUG("status=%d", 3923 p_data->disable_cfm.status); 3924 3925 if (p_data->disable_cfm.status == BTA_HL_STATUS_OK) 3926 { 3927 memset(p_btif_hl_cb, 0, sizeof(btif_hl_cb_t)); 3928 btif_hl_set_state(BTIF_HL_STATE_DISABLED); 3929 } 3930 3931 break; 3932 default: 3933 break; 3934 } 3935} 3936 3937/******************************************************************************* 3938** 3939** Function btif_hl_ctrl_cback 3940** 3941** Description Callback function for HL control events 3942** 3943** Returns void 3944** 3945*******************************************************************************/ 3946static void btif_hl_ctrl_cback(tBTA_HL_CTRL_EVT event, tBTA_HL_CTRL *p_data){ 3947 bt_status_t status; 3948 int param_len = 0; 3949 3950 BTIF_TRACE_DEBUG("%s event %d", __FUNCTION__, event); 3951 btif_hl_display_calling_process_name(); 3952 3953 switch ( event ) 3954 { 3955 case BTA_HL_CTRL_ENABLE_CFM_EVT: 3956 case BTA_HL_CTRL_DISABLE_CFM_EVT: 3957 param_len = sizeof(tBTA_HL_CTRL_ENABLE_DISABLE); 3958 break; 3959 default: 3960 break; 3961 } 3962 3963 status = btif_transfer_context(btif_hl_upstreams_ctrl_evt, (uint16_t)event, (void*)p_data, param_len, NULL); 3964 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status); 3965} 3966/******************************************************************************* 3967** 3968** Function connect_channel 3969** 3970** Description connect a data channel 3971** 3972** Returns bt_status_t 3973** 3974*******************************************************************************/ 3975static bt_status_t connect_channel(int app_id, bt_bdaddr_t *bd_addr, int mdep_cfg_index, int *channel_id){ 3976 UINT8 app_idx, mcl_idx; 3977 btif_hl_app_cb_t *p_acb = NULL; 3978 btif_hl_pending_chan_cb_t *p_pcb = NULL; 3979 btif_hl_mcl_cb_t *p_mcb=NULL; 3980 bt_status_t status = BT_STATUS_SUCCESS; 3981 tBTA_HL_DCH_OPEN_PARAM dch_open; 3982 BD_ADDR bda; 3983 UINT8 i; 3984 3985 CHECK_BTHL_INIT(); 3986 BTIF_TRACE_EVENT("%s", __FUNCTION__); 3987 btif_hl_display_calling_process_name(); 3988 3989 3990 for (i=0; i<6; i++) 3991 { 3992 bda[i] = (UINT8) bd_addr->address[i]; 3993 } 3994 if (btif_hl_find_app_idx(((UINT8)app_id), &app_idx)) 3995 { 3996 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 3997 if (btif_hl_find_mcl_idx(app_idx, bda , &mcl_idx)) 3998 { 3999 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 4000 if (p_mcb->is_connected) 4001 { 4002 dch_open.ctrl_psm = p_mcb->ctrl_psm; 4003 dch_open.local_mdep_id = p_acb->sup_feature.mdep[mdep_cfg_index].mdep_id; 4004 BTIF_TRACE_DEBUG("connect_channel: app_idx =%d, mdep_cfg_indx =%d, mdep_id =%d app_id= %d", app_idx, 4005 mdep_cfg_index, dch_open.local_mdep_id, app_id); 4006 if (btif_hl_find_peer_mdep_id(p_acb->app_id, p_mcb->bd_addr, 4007 p_acb->sup_feature.mdep[mdep_cfg_index].mdep_cfg.mdep_role, 4008 p_acb->sup_feature.mdep[mdep_cfg_index].mdep_cfg.data_cfg[0].data_type, &dch_open.peer_mdep_id )) 4009 { 4010 dch_open.local_cfg = p_acb->channel_type[mdep_cfg_index]; 4011 if ((p_acb->sup_feature.mdep[mdep_cfg_index].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SOURCE) 4012 && !btif_hl_is_the_first_reliable_existed(app_idx,mcl_idx)) 4013 { 4014 dch_open.local_cfg = BTA_HL_DCH_CFG_RELIABLE; 4015 } 4016 dch_open.sec_mask = (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT); 4017 4018 if( !btif_hl_dch_open(p_acb->app_id, bda, &dch_open, 4019 mdep_cfg_index, BTIF_HL_PEND_DCH_OP_OPEN, channel_id )) 4020 { 4021 status = BT_STATUS_FAIL; 4022 BTIF_TRACE_EVENT("%s loc0 status = BT_STATUS_FAIL", __FUNCTION__); 4023 } 4024 } 4025 else 4026 { 4027 p_mcb->cch_oper = BTIF_HL_CCH_OP_MDEP_FILTERING; 4028 4029 p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx); 4030 p_pcb->in_use = TRUE; 4031 p_pcb->mdep_cfg_idx = mdep_cfg_index; 4032 memcpy(p_pcb->bd_addr, bda, sizeof(BD_ADDR)); 4033 p_pcb->op = BTIF_HL_PEND_DCH_OP_OPEN; 4034 BTA_HlSdpQuery(app_id,p_acb->app_handle, bda); 4035 } 4036 } 4037 else 4038 { 4039 status = BT_STATUS_FAIL; 4040 } 4041 } 4042 else 4043 { 4044 p_acb->filter.num_elems =1; 4045 p_acb->filter.elem[0].data_type = p_acb->sup_feature.mdep[mdep_cfg_index].mdep_cfg.data_cfg[mdep_cfg_index].data_type; 4046 if (p_acb->sup_feature.mdep[mdep_cfg_index].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SINK) 4047 p_acb->filter.elem[0].peer_mdep_role = BTA_HL_MDEP_ROLE_SOURCE; 4048 else 4049 p_acb->filter.elem[0].peer_mdep_role = BTA_HL_MDEP_ROLE_SINK; 4050 4051 if ( !btif_hl_cch_open(p_acb->app_id, bda, 0, mdep_cfg_index, 4052 BTIF_HL_PEND_DCH_OP_OPEN, 4053 channel_id)) 4054 { 4055 status = BT_STATUS_FAIL; 4056 } 4057 } 4058 } 4059 else 4060 { 4061 status = BT_STATUS_FAIL; 4062 } 4063 4064 BTIF_TRACE_DEBUG("%s status=%d channel_id=0x%08x", __FUNCTION__, status, *channel_id); 4065 4066 return status; 4067} 4068/******************************************************************************* 4069** 4070** Function destroy_channel 4071** 4072** Description destroy a data channel 4073** 4074** Returns bt_status_t 4075** 4076*******************************************************************************/ 4077static bt_status_t destroy_channel(int channel_id){ 4078 UINT8 app_idx, mcl_idx, mdl_idx, mdl_cfg_idx, app_id, mdep_cfg_idx = 0; 4079 bt_status_t status = BT_STATUS_SUCCESS; 4080 btif_hl_mdl_cfg_t *p_mdl; 4081 btif_hl_mcl_cb_t *p_mcb; 4082 btif_hl_mdl_cb_t *p_dcb; 4083 btif_hl_app_cb_t *p_acb; 4084 4085 CHECK_BTHL_INIT(); 4086 BTIF_TRACE_EVENT("%s channel_id=0x%08x", __FUNCTION__, channel_id); 4087 btif_hl_display_calling_process_name(); 4088 4089 4090 if (btif_hl_if_channel_setup_pending(channel_id, &app_idx, &mcl_idx)) 4091 { 4092 btif_hl_dch_abort(app_idx, mcl_idx); 4093 } 4094 else 4095 { 4096 if (btif_hl_find_mdl_cfg_idx_using_channel_id(channel_id, &app_idx, &mdl_cfg_idx)) 4097 // if(btif_hl_find_mdl_idx_using_channel_id(channel_id, &app_idx,&mcl_idx, &mdl_idx)) 4098 { 4099 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 4100 if (!p_acb->delete_mdl.active) 4101 { 4102 p_mdl =BTIF_HL_GET_MDL_CFG_PTR(app_idx, mdl_cfg_idx); 4103 p_acb->delete_mdl.active = TRUE; 4104 p_acb->delete_mdl.mdl_id = p_mdl->base.mdl_id; 4105 p_acb->delete_mdl.channel_id = channel_id; 4106 p_acb->delete_mdl.mdep_cfg_idx = p_mdl->extra.mdep_cfg_idx; 4107 memcpy(p_acb->delete_mdl.bd_addr, p_mdl->base.peer_bd_addr,sizeof(BD_ADDR)); 4108 4109 if (btif_hl_find_mcl_idx(app_idx, p_mdl->base.peer_bd_addr, &mcl_idx)) 4110 { 4111 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 4112 if (p_mcb->is_connected) 4113 { 4114 BTIF_TRACE_DEBUG("calling BTA_HlDeleteMdl mdl_id=%d",p_acb->delete_mdl.mdl_id ); 4115 BTA_HlDeleteMdl(p_mcb->mcl_handle, p_acb->delete_mdl.mdl_id); 4116 } 4117 else 4118 { 4119 status = BT_STATUS_FAIL; 4120 } 4121 } 4122 else 4123 { 4124 BTIF_TRACE_DEBUG("btif_hl_delete_mdl calling btif_hl_cch_open" ); 4125 mdep_cfg_idx = p_mdl->extra.mdep_cfg_idx; 4126 p_acb->filter.num_elems =1; 4127 p_acb->filter.elem[0].data_type = p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg.data_cfg[mdep_cfg_idx].data_type; 4128 if (p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg.mdep_role == BTA_HL_MDEP_ROLE_SINK) 4129 p_acb->filter.elem[0].peer_mdep_role = BTA_HL_MDEP_ROLE_SOURCE; 4130 else 4131 p_acb->filter.elem[0].peer_mdep_role = BTA_HL_MDEP_ROLE_SINK; 4132 if (btif_hl_cch_open(p_acb->app_id, p_acb->delete_mdl.bd_addr, 0, 4133 mdep_cfg_idx, 4134 BTIF_HL_PEND_DCH_OP_DELETE_MDL, NULL)) 4135 { 4136 status = BT_STATUS_FAIL; 4137 } 4138 } 4139 4140 if ( status == BT_STATUS_FAIL) 4141 { 4142 /* fail for now */ 4143 btif_hl_clean_delete_mdl(&p_acb->delete_mdl); 4144 } 4145 } 4146 else 4147 { 4148 status = BT_STATUS_BUSY; 4149 } 4150 } 4151 else 4152 { 4153 status = BT_STATUS_FAIL; 4154 } 4155 4156 } 4157 return status; 4158} 4159/******************************************************************************* 4160** 4161** Function unregister_application 4162** 4163** Description unregister an HDP application 4164** 4165** Returns bt_status_t 4166** 4167*******************************************************************************/ 4168static bt_status_t unregister_application(int app_id){ 4169 btif_hl_app_cb_t *p_acb; 4170 UINT8 app_idx; 4171 int len; 4172 bt_status_t status = BT_STATUS_SUCCESS; 4173 btif_hl_evt_cb_t evt_param; 4174 4175 CHECK_BTHL_INIT(); 4176 BTIF_TRACE_EVENT("%s app_id=%d", __FUNCTION__, app_id); 4177 btif_hl_display_calling_process_name(); 4178 4179 if (btif_hl_find_app_idx(((UINT8)app_id), &app_idx)) 4180 { 4181 evt_param.unreg.app_idx = app_idx; 4182 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 4183 reg_counter --; 4184 len = sizeof(btif_hl_unreg_t); 4185 status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_UNREG_APP, 4186 (char*) &evt_param, len, NULL); 4187 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status); 4188 } 4189 else 4190 { 4191 status = BT_STATUS_FAIL; 4192 } 4193 4194 BTIF_TRACE_DEBUG("de-reg return status=%d", status); 4195 return status; 4196} 4197/******************************************************************************* 4198** 4199** Function register_application 4200** 4201** Description register an HDP application 4202** 4203** Returns bt_status_t 4204** 4205*******************************************************************************/ 4206static bt_status_t register_application(bthl_reg_param_t *p_reg_param, int *app_id){ 4207 btif_hl_app_cb_t *p_acb; 4208 tBTA_HL_SUP_FEATURE *p_sup; 4209 tBTA_HL_MDEP_CFG *p_cfg; 4210 tBTA_HL_MDEP_DATA_TYPE_CFG *p_data; 4211 UINT8 app_idx=0, i=0, pending_reg_idx=0; 4212 bthl_mdep_cfg_t *p_mdep_cfg; 4213 bt_status_t status = BT_STATUS_SUCCESS; 4214 btif_hl_evt_cb_t evt_param; 4215 int len; 4216 4217 CHECK_BTHL_INIT(); 4218 BTIF_TRACE_EVENT("%s", __FUNCTION__); 4219 btif_hl_display_calling_process_name(); 4220 4221 if (btif_hl_get_state() == BTIF_HL_STATE_DISABLED) 4222 { 4223 btif_hl_init(); 4224 btif_hl_set_state(BTIF_HL_STATE_ENABLING); 4225 BTA_HlEnable(btif_hl_ctrl_cback); 4226 } 4227 4228 if (!btif_hl_find_avail_app_idx(&app_idx)) 4229 { 4230 BTIF_TRACE_ERROR("Unable to allocate a new application control block"); 4231 return BT_STATUS_FAIL; 4232 } 4233 4234 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 4235 p_acb->in_use = TRUE; 4236 4237 4238 p_acb->app_id = btif_hl_get_next_app_id(); 4239 4240 if (p_reg_param->application_name != NULL ) 4241 strncpy(p_acb->application_name, p_reg_param->application_name, BTIF_HL_APPLICATION_NAME_LEN); 4242 4243 if (p_reg_param->provider_name != NULL ) 4244 strncpy(p_acb->provider_name, p_reg_param->provider_name, BTA_PROVIDER_NAME_LEN); 4245 4246 if (p_reg_param->srv_name != NULL ) 4247 strncpy(p_acb->srv_name, p_reg_param->srv_name, BTA_SERVICE_NAME_LEN); 4248 4249 if (p_reg_param->srv_desp != NULL ) 4250 strncpy(p_acb->srv_desp, p_reg_param->srv_desp, BTA_SERVICE_DESP_LEN); 4251 4252 p_sup = &p_acb->sup_feature; 4253 p_sup->advertize_source_sdp = TRUE; 4254 p_sup->echo_cfg.max_rx_apdu_size = BTIF_HL_ECHO_MAX_TX_RX_APDU_SIZE; 4255 p_sup->echo_cfg.max_tx_apdu_size = BTIF_HL_ECHO_MAX_TX_RX_APDU_SIZE; 4256 p_sup->num_of_mdeps = p_reg_param->number_of_mdeps; 4257 4258 for (i=0, p_mdep_cfg = p_reg_param->mdep_cfg ; i< p_sup->num_of_mdeps; i++, p_mdep_cfg++ ) 4259 { 4260 p_cfg = &p_sup->mdep[i].mdep_cfg; 4261 p_cfg->num_of_mdep_data_types = 1; 4262 p_data = &p_cfg->data_cfg[0]; 4263 4264 if ( !btif_hl_get_bta_mdep_role(p_mdep_cfg->mdep_role, &(p_cfg->mdep_role))) 4265 { 4266 BTIF_TRACE_ERROR("Invalid mdep_role=%d", p_mdep_cfg->mdep_role); 4267 status = BT_STATUS_FAIL; 4268 break; 4269 } 4270 else 4271 { 4272 if (p_cfg->mdep_role == BTA_HL_MDEP_ROLE_SINK ) 4273 p_sup->app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SINK; 4274 else 4275 p_sup->app_role_mask |= BTA_HL_MDEP_ROLE_MASK_SOURCE; 4276 4277 if ( (p_sup->app_role_mask & BTA_HL_MDEP_ROLE_MASK_SINK) && 4278 (p_sup->app_role_mask & BTA_HL_MDEP_ROLE_MASK_SINK) ) 4279 { 4280 p_acb->dev_type = BTA_HL_DEVICE_TYPE_DUAL; 4281 } 4282 else if ( p_sup->app_role_mask & BTA_HL_MDEP_ROLE_MASK_SINK ) 4283 p_acb->dev_type = BTA_HL_DEVICE_TYPE_SINK; 4284 else 4285 4286 p_acb->dev_type = BTA_HL_DEVICE_TYPE_SOURCE; 4287 4288 p_data->data_type = (UINT16) p_mdep_cfg->data_type; 4289 p_data->max_rx_apdu_size = btif_hl_get_max_rx_apdu_size(p_cfg->mdep_role, p_data->data_type); 4290 p_data->max_tx_apdu_size = btif_hl_get_max_tx_apdu_size(p_cfg->mdep_role, p_data->data_type); 4291 4292 if (p_mdep_cfg->mdep_description != NULL ) 4293 strncpy(p_data->desp, p_mdep_cfg->mdep_description, BTA_SERVICE_DESP_LEN); 4294 4295 if ( !btif_hl_get_bta_channel_type(p_mdep_cfg->channel_type, &(p_acb->channel_type[i]))) 4296 { 4297 BTIF_TRACE_ERROR("Invalid channel_type=%d", p_mdep_cfg->channel_type); 4298 status = BT_STATUS_FAIL; 4299 break; 4300 } 4301 } 4302 } 4303 4304 if (status == BT_STATUS_SUCCESS) 4305 { 4306 *app_id = (int) p_acb->app_id; 4307 evt_param.reg.app_idx = app_idx; 4308 len = sizeof(btif_hl_reg_t); 4309 p_acb->reg_pending = TRUE; 4310 reg_counter++; 4311 BTIF_TRACE_DEBUG("calling btif_transfer_context status=%d app_id=%d", status, *app_id); 4312 status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_REG_APP, 4313 (char*) &evt_param, len, NULL); 4314 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status); 4315 4316 } 4317 else 4318 { 4319 btif_hl_free_app_idx(app_idx); 4320 } 4321 4322 BTIF_TRACE_DEBUG("register_application status=%d app_id=%d", status, *app_id); 4323 return status; 4324} 4325 4326/******************************************************************************* 4327** 4328** Function btif_hl_save_mdl_cfg 4329** 4330** Description Save the MDL configuration 4331** 4332** Returns BOOLEAN 4333** 4334*******************************************************************************/ 4335BOOLEAN btif_hl_save_mdl_cfg(UINT8 mdep_id, UINT8 item_idx, 4336 tBTA_HL_MDL_CFG *p_mdl_cfg){ 4337 btif_hl_mdl_cfg_t *p_mdl=NULL; 4338 BOOLEAN success = FALSE; 4339 btif_hl_app_cb_t *p_acb; 4340 btif_hl_mcl_cb_t *p_mcb; 4341 UINT8 app_idx, mcl_idx, mdl_idx, len; 4342 bt_status_t bt_status; 4343 btif_hl_evt_cb_t evt_param; 4344 int *p_channel_id; 4345 4346 BTIF_TRACE_DEBUG("%s mdep_id=%d item_idx=%d, local_mdep_id=%d mdl_id=0x%x dch_mode=%d", 4347 __FUNCTION__, mdep_id, item_idx, p_mdl_cfg->local_mdep_id, 4348 p_mdl_cfg->mdl_id, p_mdl_cfg->dch_mode ); 4349 4350 if(btif_hl_find_app_idx_using_mdepId(mdep_id,&app_idx)) 4351 { 4352 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 4353 p_mdl = BTIF_HL_GET_MDL_CFG_PTR(app_idx, item_idx); 4354 p_channel_id = BTIF_HL_GET_MDL_CFG_CHANNEL_ID_PTR(app_idx, item_idx); 4355 if (p_mdl) 4356 { 4357 memcpy(&p_mdl->base, p_mdl_cfg, sizeof(tBTA_HL_MDL_CFG)); 4358 if (btif_hl_find_mcl_idx(app_idx, p_mdl->base.peer_bd_addr , &mcl_idx)) 4359 { 4360 p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 4361 if (p_mcb->pcb.in_use) 4362 *p_channel_id = p_mcb->pcb.channel_id; 4363 else 4364 *p_channel_id = btif_hl_get_next_channel_id(p_acb->app_id); 4365 p_mdl->extra.mdep_cfg_idx = p_mcb->pcb.mdep_cfg_idx; 4366 p_mdl->extra.data_type = p_acb->sup_feature.mdep[p_mcb->pcb.mdep_cfg_idx].mdep_cfg.data_cfg[0].data_type; 4367 4368 if (!btif_hl_find_peer_mdep_id(p_acb->app_id, p_mcb->bd_addr, 4369 p_acb->sup_feature.mdep[p_mcb->pcb.mdep_cfg_idx].mdep_cfg.mdep_role, 4370 p_acb->sup_feature.mdep[p_mcb->pcb.mdep_cfg_idx].mdep_cfg.data_cfg[0].data_type, 4371 &p_mdl->extra.peer_mdep_id)) 4372 { 4373 p_mdl->extra.peer_mdep_id = BTA_HL_INVALID_MDEP_ID; 4374 } 4375 BTIF_TRACE_DEBUG("%s app_idx=%d item_idx=%d mld_id=0x%x", 4376 __FUNCTION__, app_idx, item_idx, p_mdl->base.mdl_id); 4377 evt_param.update_mdl.app_idx = app_idx; 4378 len = sizeof(btif_hl_update_mdl_t); 4379 BTIF_TRACE_DEBUG("send BTIF_HL_UPDATE_MDL event app_idx=%d ",app_idx); 4380 if ((bt_status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_UPDATE_MDL, 4381 (char*) &evt_param, len, NULL)) == BT_STATUS_SUCCESS) 4382 { 4383 success = TRUE; 4384 } 4385 ASSERTC(bt_status == BT_STATUS_SUCCESS, "context transfer failed", bt_status); 4386 } 4387 } 4388 } 4389 BTIF_TRACE_DEBUG("%s success=%d ",__FUNCTION__, success ); 4390 4391 return success; 4392} 4393 4394/******************************************************************************* 4395** 4396** Function btif_hl_delete_mdl_cfg 4397** 4398** Description Delete the MDL configuration 4399** 4400** Returns BOOLEAN 4401** 4402*******************************************************************************/ 4403BOOLEAN btif_hl_delete_mdl_cfg(UINT8 mdep_id, UINT8 item_idx){ 4404 btif_hl_mdl_cfg_t *p_mdl=NULL; 4405 BOOLEAN success = FALSE; 4406 btif_hl_app_cb_t *p_acb; 4407 UINT8 app_idx, len; 4408 bt_status_t bt_status; 4409 btif_hl_evt_cb_t evt_param; 4410 4411 if(btif_hl_find_app_idx_using_mdepId(mdep_id,&app_idx)) 4412 { 4413 4414 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 4415 4416 p_mdl = BTIF_HL_GET_MDL_CFG_PTR(app_idx, item_idx); 4417 if (p_mdl) 4418 { 4419 memset(p_mdl, 0, sizeof(btif_hl_mdl_cfg_t)); 4420 evt_param.update_mdl.app_idx = app_idx; 4421 len = sizeof(btif_hl_update_mdl_t); 4422 BTIF_TRACE_DEBUG("send BTIF_HL_UPDATE_MDL event app_idx=%d ",app_idx); 4423 if ((bt_status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_UPDATE_MDL, 4424 (char*) &evt_param, len, NULL)) == BT_STATUS_SUCCESS) 4425 { 4426 success = TRUE; 4427 } 4428 ASSERTC(bt_status == BT_STATUS_SUCCESS, "context transfer failed", bt_status); 4429 } 4430 } 4431 4432 BTIF_TRACE_DEBUG("%s success=%d ",__FUNCTION__, success ); 4433 return success; 4434} 4435 4436/******************************************************************************* 4437** 4438** Function init 4439** 4440** Description initializes the hl interface 4441** 4442** Returns bt_status_t 4443** 4444*******************************************************************************/ 4445static bt_status_t init( bthl_callbacks_t* callbacks ){ 4446 bt_status_t status = BT_STATUS_SUCCESS; 4447 4448 BTIF_TRACE_EVENT("%s", __FUNCTION__); 4449 btif_hl_display_calling_process_name(); 4450 bt_hl_callbacks_cb = *callbacks; 4451 bt_hl_callbacks = &bt_hl_callbacks_cb; 4452 btif_hl_soc_thread_init(); 4453 reg_counter = 0; 4454 return status; 4455} 4456/******************************************************************************* 4457** 4458** Function cleanup 4459** 4460** Description Closes the HL interface 4461** 4462** Returns void 4463** 4464*******************************************************************************/ 4465static void cleanup( void ){ 4466 BTIF_TRACE_EVENT("%s", __FUNCTION__); 4467 btif_hl_display_calling_process_name(); 4468 if (bt_hl_callbacks) 4469 { 4470 btif_disable_service(BTA_HDP_SERVICE_ID); 4471 bt_hl_callbacks = NULL; 4472 reg_counter = 0; 4473 } 4474 4475 btif_hl_disable(); 4476 btif_hl_close_select_thread(); 4477} 4478 4479static const bthl_interface_t bthlInterface = { 4480 sizeof(bthl_interface_t), 4481 init, 4482 register_application, 4483 unregister_application, 4484 connect_channel, 4485 destroy_channel, 4486 cleanup, 4487}; 4488 4489 4490/******************************************************************************* 4491** 4492** Function btif_hl_get_interface 4493** 4494** Description Get the hl callback interface 4495** 4496** Returns bthf_interface_t 4497** 4498*******************************************************************************/ 4499const bthl_interface_t *btif_hl_get_interface(){ 4500 BTIF_TRACE_EVENT("%s", __FUNCTION__); 4501 return &bthlInterface; 4502} 4503 4504/******************************************************************************* 4505** 4506** Function btif_hl_update_maxfd 4507** 4508** Description Update the max fd if the input fd is greater than the current max fd 4509** 4510** Returns int 4511** 4512*******************************************************************************/ 4513int btif_hl_update_maxfd( int max_org_s){ 4514 btif_hl_soc_cb_t *p_scb = NULL; 4515 int maxfd=0; 4516 4517 BTIF_TRACE_DEBUG("btif_hl_update_maxfd max_org_s= %d", max_org_s); 4518 4519 maxfd = max_org_s; 4520 if (!GKI_queue_is_empty(&soc_queue)) 4521 { 4522 p_scb = (btif_hl_soc_cb_t *)GKI_getfirst((void *)&soc_queue); 4523 if (maxfd < p_scb->max_s) 4524 { 4525 maxfd = p_scb->max_s; 4526 BTIF_TRACE_DEBUG("btif_hl_update_maxfd 1 maxfd=%d", maxfd); 4527 } 4528 while (p_scb != NULL) 4529 { 4530 if (maxfd < p_scb->max_s) 4531 { 4532 maxfd = p_scb->max_s; 4533 BTIF_TRACE_DEBUG("btif_hl_update_maxfd 2 maxfd=%d", maxfd); 4534 } 4535 p_scb = (btif_hl_soc_cb_t *)GKI_getnext((void *)p_scb ); 4536 } 4537 } 4538 4539 BTIF_TRACE_DEBUG("btif_hl_update_maxfd final *p_max_s=%d", maxfd); 4540 return maxfd; 4541} 4542/******************************************************************************* 4543** 4544** Function btif_hl_get_socket_state 4545** 4546** Description get socket state 4547** 4548** Returns btif_hl_soc_state_t 4549** 4550*******************************************************************************/ 4551btif_hl_soc_state_t btif_hl_get_socket_state(btif_hl_soc_cb_t *p_scb){ 4552 BTIF_TRACE_DEBUG("btif_hl_get_socket_state state=%d", p_scb->state); 4553 return p_scb->state; 4554} 4555/******************************************************************************* 4556** 4557** Function btif_hl_set_socket_state 4558** 4559** Description set socket state 4560** 4561** Returns void 4562** 4563*******************************************************************************/ 4564void btif_hl_set_socket_state(btif_hl_soc_cb_t *p_scb, btif_hl_soc_state_t new_state){ 4565 BTIF_TRACE_DEBUG("btif_hl_set_socket_state %d---->%d", p_scb->state, new_state); 4566 p_scb->state = new_state; 4567} 4568/******************************************************************************* 4569** 4570** Function btif_hl_release_mcl_sockets 4571** 4572** Description Release all sockets on the MCL 4573** 4574** Returns void 4575** 4576*******************************************************************************/ 4577void btif_hl_release_mcl_sockets(UINT8 app_idx, UINT8 mcl_idx){ 4578 btif_hl_soc_cb_t *p_scb = NULL; 4579 UINT8 i; 4580 btif_hl_mdl_cb_t *p_dcb; 4581 BOOLEAN found= FALSE; 4582 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 4583 for (i=0; i < BTA_HL_NUM_MDLS_PER_MCL ; i ++) 4584 { 4585 p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, i); 4586 if (p_dcb && p_dcb->in_use && p_dcb->p_scb) 4587 { 4588 BTIF_TRACE_DEBUG("found socket for app_idx=%d mcl_id=%d, mdl_idx=%d", app_idx, mcl_idx, i); 4589 btif_hl_set_socket_state (p_dcb->p_scb, BTIF_HL_SOC_STATE_W4_REL); 4590 p_dcb->p_scb = NULL; 4591 found = TRUE; 4592 } 4593 } 4594 if (found) 4595 btif_hl_select_close_connected(); 4596} 4597/******************************************************************************* 4598** 4599** Function btif_hl_release_socket 4600** 4601** Description release a specified socket 4602** 4603** Returns void 4604** 4605*******************************************************************************/ 4606void btif_hl_release_socket(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx){ 4607 btif_hl_soc_cb_t *p_scb = NULL; 4608 btif_hl_mdl_cb_t *p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); 4609 4610 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 4611 BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d mdl_idx=%d", app_idx, mcl_idx, mdl_idx ); 4612 4613 if (p_dcb && p_dcb->p_scb) 4614 { 4615 p_scb = p_dcb->p_scb; 4616 btif_hl_set_socket_state(p_scb, BTIF_HL_SOC_STATE_W4_REL); 4617 p_dcb->p_scb = NULL; 4618 btif_hl_select_close_connected(); 4619 } 4620} 4621/******************************************************************************* 4622** 4623** Function btif_hl_create_socket 4624** 4625** Description create a socket 4626** 4627** Returns BOOLEAN 4628** 4629*******************************************************************************/ 4630BOOLEAN btif_hl_create_socket(UINT8 app_idx, UINT8 mcl_idx, UINT8 mdl_idx){ 4631 btif_hl_mcl_cb_t *p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 4632 btif_hl_mdl_cb_t *p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); 4633 btif_hl_soc_cb_t *p_scb = NULL; 4634 UINT8 soc_idx; 4635 BOOLEAN status = FALSE; 4636 4637 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 4638 4639 if (p_dcb && ((p_scb = (btif_hl_soc_cb_t *)GKI_getbuf((UINT16)sizeof(btif_hl_soc_cb_t)))!=NULL)) 4640 { 4641 if (socketpair(AF_UNIX, SOCK_STREAM, 0, p_scb->socket_id) >= 0) 4642 { 4643 BTIF_TRACE_DEBUG("socket id[0]=%d id[1]=%d",p_scb->socket_id[0], p_scb->socket_id[1] ); 4644 p_dcb->p_scb = p_scb; 4645 p_scb->app_idx = app_idx; 4646 p_scb->mcl_idx = mcl_idx; 4647 p_scb->mdl_idx = mdl_idx; 4648 p_scb->channel_id = p_dcb->channel_id; 4649 p_scb->mdep_cfg_idx = p_dcb->local_mdep_cfg_idx; 4650 memcpy(p_scb->bd_addr, p_mcb->bd_addr,sizeof(BD_ADDR)); 4651 btif_hl_set_socket_state(p_scb, BTIF_HL_SOC_STATE_W4_ADD); 4652 p_scb->max_s = p_scb->socket_id[1]; 4653 GKI_enqueue(&soc_queue, (void *) p_scb); 4654 btif_hl_select_wakeup(); 4655 status = TRUE; 4656 } 4657 else 4658 { 4659 4660 btif_hl_free_buf((void **)&p_scb); 4661 } 4662 } 4663 4664 BTIF_TRACE_DEBUG("%s status=%d", __FUNCTION__, status); 4665 return status; 4666} 4667/******************************************************************************* 4668** 4669** Function btif_hl_add_socket_to_set 4670** 4671** Description Add a socket 4672** 4673** Returns void 4674** 4675*******************************************************************************/ 4676void btif_hl_add_socket_to_set( fd_set *p_org_set){ 4677 btif_hl_soc_cb_t *p_scb = NULL; 4678 btif_hl_mdl_cb_t *p_dcb = NULL; 4679 btif_hl_mcl_cb_t *p_mcb = NULL; 4680 btif_hl_app_cb_t *p_acb = NULL; 4681 btif_hl_evt_cb_t evt_param; 4682 bt_status_t status; 4683 int len; 4684 4685 BTIF_TRACE_DEBUG("entering %s",__FUNCTION__); 4686 4687 if (!GKI_queue_is_empty(&soc_queue)) 4688 { 4689 p_scb = (btif_hl_soc_cb_t *)GKI_getfirst((void *)&soc_queue); 4690 BTIF_TRACE_DEBUG("btif_hl_add_socket_to_set first p_scb=0x%x", p_scb); 4691 while (p_scb != NULL) 4692 { 4693 if (btif_hl_get_socket_state(p_scb) == BTIF_HL_SOC_STATE_W4_ADD) 4694 { 4695 btif_hl_set_socket_state(p_scb, BTIF_HL_SOC_STATE_W4_READ); 4696 FD_SET(p_scb->socket_id[1], p_org_set); 4697 BTIF_TRACE_DEBUG("found and set socket_id=%d is_set=%d", p_scb->socket_id[1], FD_ISSET(p_scb->socket_id[1], p_org_set)); 4698 p_mcb = BTIF_HL_GET_MCL_CB_PTR(p_scb->app_idx, p_scb->mcl_idx); 4699 p_dcb = BTIF_HL_GET_MDL_CB_PTR(p_scb->app_idx, p_scb->mcl_idx, p_scb->mdl_idx); 4700 p_acb = BTIF_HL_GET_APP_CB_PTR(p_scb->app_idx); 4701 if (p_mcb && p_dcb) 4702 { 4703 btif_hl_stop_timer_using_handle(p_mcb->mcl_handle); 4704 evt_param.chan_cb.app_id = p_acb->app_id; 4705 memcpy(evt_param.chan_cb.bd_addr, p_mcb->bd_addr, sizeof(BD_ADDR)); 4706 evt_param.chan_cb.channel_id = p_dcb->channel_id; 4707 evt_param.chan_cb.fd = p_scb->socket_id[0]; 4708 evt_param.chan_cb.mdep_cfg_index = (int ) p_dcb->local_mdep_cfg_idx; 4709 evt_param.chan_cb.cb_state = BTIF_HL_CHAN_CB_STATE_CONNECTED_PENDING; 4710 len = sizeof(btif_hl_send_chan_state_cb_t); 4711 status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_SEND_CONNECTED_CB, 4712 (char*) &evt_param, len, NULL); 4713 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status); 4714 } 4715 } 4716 p_scb = (btif_hl_soc_cb_t *)GKI_getnext((void *)p_scb ); 4717 BTIF_TRACE_DEBUG("next p_scb=0x%x", p_scb); 4718 } 4719 } 4720 4721 BTIF_TRACE_DEBUG("leaving %s",__FUNCTION__); 4722} 4723/******************************************************************************* 4724** 4725** Function btif_hl_close_socket 4726** 4727** Description close a socket 4728** 4729** Returns void 4730** 4731*******************************************************************************/ 4732void btif_hl_close_socket( fd_set *p_org_set){ 4733 btif_hl_soc_cb_t *p_scb = NULL; 4734 BOOLEAN element_removed = FALSE; 4735 btif_hl_mdl_cb_t *p_dcb = NULL ; 4736 btif_hl_app_cb_t *p_acb = NULL ; 4737 btif_hl_evt_cb_t evt_param; 4738 int len; 4739 int app_idx; 4740 bt_status_t status; 4741 4742 BTIF_TRACE_DEBUG("entering %s",__FUNCTION__); 4743 if (!GKI_queue_is_empty(&soc_queue)) 4744 { 4745 p_scb = (btif_hl_soc_cb_t *)GKI_getfirst((void *)&soc_queue); 4746 while (p_scb != NULL) 4747 { 4748 if (btif_hl_get_socket_state(p_scb) == BTIF_HL_SOC_STATE_W4_REL) 4749 { 4750 BTIF_TRACE_DEBUG("app_idx=%d mcl_id=%d, mdl_idx=%d", 4751 p_scb->app_idx, p_scb->mcl_idx, p_scb->mdl_idx); 4752 btif_hl_set_socket_state(p_scb, BTIF_HL_SOC_STATE_IDLE); 4753 if (p_scb->socket_id[1] != -1) 4754 { 4755 FD_CLR(p_scb->socket_id[1] , p_org_set); 4756 shutdown(p_scb->socket_id[1], SHUT_RDWR); 4757 close(p_scb->socket_id[1]); 4758 4759 evt_param.chan_cb.app_id = (int) btif_hl_get_app_id(p_scb->channel_id); 4760 memcpy(evt_param.chan_cb.bd_addr, p_scb->bd_addr, sizeof(BD_ADDR)); 4761 evt_param.chan_cb.channel_id = p_scb->channel_id; 4762 evt_param.chan_cb.fd = p_scb->socket_id[0]; 4763 evt_param.chan_cb.mdep_cfg_index = (int ) p_scb->mdep_cfg_idx; 4764 evt_param.chan_cb.cb_state = BTIF_HL_CHAN_CB_STATE_DISCONNECTED_PENDING; 4765 len = sizeof(btif_hl_send_chan_state_cb_t); 4766 status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_SEND_DISCONNECTED_CB, 4767 (char*) &evt_param, len, NULL); 4768 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status); 4769 4770 4771 } 4772 } 4773 p_scb = (btif_hl_soc_cb_t *)GKI_getnext((void *)p_scb ); 4774 BTIF_TRACE_DEBUG("while loop next p_scb=0x%x", p_scb); 4775 } 4776 4777 p_scb = (btif_hl_soc_cb_t *)GKI_getfirst((void *)&soc_queue); 4778 while (p_scb != NULL) 4779 { 4780 if (btif_hl_get_socket_state(p_scb) == BTIF_HL_SOC_STATE_IDLE) 4781 { 4782 p_dcb = BTIF_HL_GET_MDL_CB_PTR(p_scb->app_idx, p_scb->mcl_idx, p_scb->mdl_idx); 4783 BTIF_TRACE_DEBUG("idle socket app_idx=%d mcl_id=%d, mdl_idx=%d p_dcb->in_use=%d", 4784 p_scb->app_idx, p_scb->mcl_idx, p_scb->mdl_idx, p_dcb->in_use); 4785 GKI_remove_from_queue((void *)&soc_queue, p_scb); 4786 btif_hl_free_buf((void **)&p_scb); 4787 p_dcb->p_scb = NULL; 4788 element_removed = TRUE; 4789 } 4790 BTIF_TRACE_DEBUG("element_removed=%d p_scb=0x%x", element_removed, p_scb); 4791 if (element_removed) 4792 { 4793 element_removed = FALSE; 4794 p_scb = (btif_hl_soc_cb_t *)GKI_getfirst((void *)&soc_queue); 4795 } 4796 else 4797 p_scb = (btif_hl_soc_cb_t *)GKI_getnext((void *)p_scb ); 4798 4799 BTIF_TRACE_DEBUG("while loop p_scb=0x%x", p_scb); 4800 } 4801 } 4802 BTIF_TRACE_DEBUG("leaving %s",__FUNCTION__); 4803} 4804/******************************************************************************* 4805** 4806** Function btif_hl_select_wakeup_callback 4807** 4808** Description Select wakup callback to add or close a socket 4809** 4810** Returns void 4811** 4812*******************************************************************************/ 4813 4814void btif_hl_select_wakeup_callback( fd_set *p_org_set , int wakeup_signal){ 4815 BTIF_TRACE_DEBUG("entering %s wakeup_signal=0x%04x",__FUNCTION__, wakeup_signal); 4816 4817 if (wakeup_signal == btif_hl_signal_select_wakeup ) 4818 { 4819 btif_hl_add_socket_to_set(p_org_set); 4820 } 4821 else if (wakeup_signal == btif_hl_signal_select_close_connected) 4822 { 4823 btif_hl_close_socket(p_org_set); 4824 } 4825 BTIF_TRACE_DEBUG("leaving %s",__FUNCTION__); 4826} 4827 4828/******************************************************************************* 4829** 4830** Function btif_hl_select_monitor_callback 4831** 4832** Description Select monitor callback to check pending socket actions 4833** 4834** Returns void 4835** 4836*******************************************************************************/ 4837void btif_hl_select_monitor_callback( fd_set *p_cur_set , fd_set *p_org_set){ 4838 btif_hl_soc_cb_t *p_scb = NULL; 4839 btif_hl_mdl_cb_t *p_dcb = NULL; 4840 int r; 4841 UNUSED(p_org_set); 4842 4843 BTIF_TRACE_DEBUG("entering %s",__FUNCTION__); 4844 4845 if (!GKI_queue_is_empty(&soc_queue)) 4846 { 4847 p_scb = (btif_hl_soc_cb_t *)GKI_getfirst((void *)&soc_queue); 4848 BTIF_TRACE_DEBUG(" GKI queue is not empty "); 4849 while (p_scb != NULL) 4850 { 4851 if (btif_hl_get_socket_state(p_scb) == BTIF_HL_SOC_STATE_W4_READ) 4852 { 4853 if (FD_ISSET(p_scb->socket_id[1], p_cur_set)) 4854 { 4855 BTIF_TRACE_DEBUG("read data"); 4856 BTIF_TRACE_DEBUG("state= BTIF_HL_SOC_STATE_W4_READ"); 4857 p_dcb = BTIF_HL_GET_MDL_CB_PTR(p_scb->app_idx, p_scb->mcl_idx, p_scb->mdl_idx); 4858 if (p_dcb->p_tx_pkt) 4859 { 4860 BTIF_TRACE_ERROR("Rcv new pkt but the last pkt is still not been sent tx_size=%d", p_dcb->tx_size); 4861 btif_hl_free_buf((void **) &p_dcb->p_tx_pkt); 4862 } 4863 p_dcb->p_tx_pkt = btif_hl_get_buf (p_dcb->mtu); 4864 if (p_dcb ) 4865 { 4866 //do 4867 // { 4868 // r = recv(p_scb->socket_id[1], p_dcb->p_tx_pkt, p_dcb->mtu , MSG_DONTWAIT)); 4869 // } while (r == SOCKET_ERROR && errno == EINTR); 4870 4871 if ((r = (int)recv(p_scb->socket_id[1], p_dcb->p_tx_pkt, p_dcb->mtu , MSG_DONTWAIT)) > 0) 4872 { 4873 BTIF_TRACE_DEBUG("btif_hl_select_monitor_callback send data r =%d", r); 4874 p_dcb->tx_size = r; 4875 BTIF_TRACE_DEBUG("btif_hl_select_monitor_callback send data tx_size=%d", p_dcb->tx_size ); 4876 BTA_HlSendData(p_dcb->mdl_handle, p_dcb->tx_size ); 4877 } 4878 4879 if (r <= 0 ) 4880 { 4881 BTIF_TRACE_DEBUG("btif_hl_select_monitor_callback receive failed r=%d",r); 4882 BTA_HlDchClose(p_dcb->mdl_handle ); 4883 } 4884 } 4885 } 4886 } 4887 p_scb = (btif_hl_soc_cb_t *)GKI_getnext((void *)p_scb ); 4888 } 4889 } 4890 else 4891 { 4892 BTIF_TRACE_DEBUG("btif_hl_select_monitor_queue is empty"); 4893 } 4894 BTIF_TRACE_DEBUG("leaving %s",__FUNCTION__); 4895} 4896/******************************************************************************* 4897** 4898** Function btif_hl_select_wakeup_init 4899** 4900** Description select loop wakup init 4901** 4902** Returns int 4903** 4904*******************************************************************************/ 4905static inline int btif_hl_select_wakeup_init(fd_set* set){ 4906 BTIF_TRACE_DEBUG("%s", __func__); 4907 if (signal_fds[0] == -1 && socketpair(AF_UNIX, SOCK_STREAM, 0, signal_fds) < 0) 4908 { 4909 BTIF_TRACE_ERROR("socketpair failed: %s", strerror(errno)); 4910 return -1; 4911 } 4912 4913 BTIF_TRACE_DEBUG("btif_hl_select_wakeup_init signal_fds[0]=%d signal_fds[1]=%d",signal_fds[0], signal_fds[1] ); 4914 FD_SET(signal_fds[0], set); 4915 4916 return signal_fds[0]; 4917} 4918 4919/******************************************************************************* 4920** 4921** Function btif_hl_select_wakeup 4922** 4923** Description send a signal to wakupo the select loop 4924** 4925** Returns int 4926** 4927*******************************************************************************/ 4928static inline int btif_hl_select_wakeup(void){ 4929 char sig_on = btif_hl_signal_select_wakeup; 4930 BTIF_TRACE_DEBUG("btif_hl_select_wakeup"); 4931 return send(signal_fds[1], &sig_on, sizeof(sig_on), 0); 4932} 4933 4934/******************************************************************************* 4935** 4936** Function btif_hl_select_close_connected 4937** 4938** Description send a signal to close a socket 4939** 4940** Returns int 4941** 4942*******************************************************************************/ 4943static inline int btif_hl_select_close_connected(void){ 4944 char sig_on = btif_hl_signal_select_close_connected; 4945 BTIF_TRACE_DEBUG("btif_hl_select_close_connected"); 4946 return send(signal_fds[1], &sig_on, sizeof(sig_on), 0); 4947} 4948 4949/******************************************************************************* 4950** 4951** Function btif_hl_close_select_thread 4952** 4953** Description send signal to close the thread and then close all signal FDs 4954** 4955** Returns int 4956** 4957*******************************************************************************/ 4958static inline int btif_hl_close_select_thread(void) 4959{ 4960 int result = 0; 4961 char sig_on = btif_hl_signal_select_exit; 4962 BTIF_TRACE_DEBUG("btif_hl_signal_select_exit"); 4963 result = send(signal_fds[1], &sig_on, sizeof(sig_on), 0); 4964 if (btif_is_enabled()) 4965 { 4966 /* Wait for the select_thread_id to exit if BT is still enabled 4967 and only this profile getting cleaned up*/ 4968 if (select_thread_id != -1) { 4969 pthread_join(select_thread_id, NULL); 4970 select_thread_id = -1; 4971 } 4972 } 4973 return result; 4974} 4975 4976/******************************************************************************* 4977** 4978** Function btif_hl_select_wake_reset 4979** 4980** Description clear the received signal for the select loop 4981** 4982** Returns int 4983** 4984*******************************************************************************/ 4985static inline int btif_hl_select_wake_reset(void){ 4986 char sig_recv = 0; 4987 4988 BTIF_TRACE_DEBUG("btif_hl_select_wake_reset"); 4989 recv(signal_fds[0], &sig_recv, sizeof(sig_recv), MSG_WAITALL); 4990 return(int)sig_recv; 4991} 4992/******************************************************************************* 4993** 4994** Function btif_hl_select_wake_signaled 4995** 4996** Description check whether a fd is set or not 4997** 4998** Returns int 4999** 5000*******************************************************************************/ 5001static inline int btif_hl_select_wake_signaled(fd_set* set){ 5002 BTIF_TRACE_DEBUG("btif_hl_select_wake_signaled"); 5003 return FD_ISSET(signal_fds[0], set); 5004} 5005/******************************************************************************* 5006** 5007** Function btif_hl_thread_cleanup 5008** 5009** Description shut down and clean up the select loop 5010** 5011** Returns void 5012** 5013*******************************************************************************/ 5014static void btif_hl_thread_cleanup(){ 5015 if (listen_s != -1) 5016 close(listen_s); 5017 if (connected_s != -1) 5018 { 5019 shutdown(connected_s, SHUT_RDWR); 5020 close(connected_s); 5021 } 5022 listen_s = connected_s = -1; 5023 BTIF_TRACE_DEBUG("hl thread cleanup"); 5024} 5025/******************************************************************************* 5026** 5027** Function btif_hl_select_thread 5028** 5029** Description the select loop 5030** 5031** Returns void 5032** 5033*******************************************************************************/ 5034static void *btif_hl_select_thread(void *arg){ 5035 fd_set org_set, curr_set; 5036 int r, max_curr_s, max_org_s; 5037 UNUSED(arg); 5038 5039 BTIF_TRACE_DEBUG("entered btif_hl_select_thread"); 5040 FD_ZERO(&org_set); 5041 max_org_s = btif_hl_select_wakeup_init(&org_set); 5042 BTIF_TRACE_DEBUG("max_s=%d ", max_org_s); 5043 5044 for (;;) 5045 { 5046 r = 0; 5047 BTIF_TRACE_DEBUG("set curr_set = org_set "); 5048 curr_set = org_set; 5049 max_curr_s = max_org_s; 5050 int ret = select((max_curr_s + 1), &curr_set, NULL, NULL, NULL); 5051 BTIF_TRACE_DEBUG("select unblocked ret=%d", ret); 5052 if (ret == -1) 5053 { 5054 BTIF_TRACE_DEBUG("select() ret -1, exit the thread"); 5055 btif_hl_thread_cleanup(); 5056 select_thread_id = -1; 5057 return 0; 5058 } 5059 else if (ret) 5060 { 5061 BTIF_TRACE_DEBUG("btif_hl_select_wake_signaled, signal ret=%d", ret); 5062 if (btif_hl_select_wake_signaled(&curr_set)) 5063 { 5064 r = btif_hl_select_wake_reset(); 5065 BTIF_TRACE_DEBUG("btif_hl_select_wake_signaled, signal:%d", r); 5066 if (r == btif_hl_signal_select_wakeup || r == btif_hl_signal_select_close_connected ) 5067 { 5068 btif_hl_select_wakeup_callback(&org_set, r); 5069 } 5070 else if( r == btif_hl_signal_select_exit) 5071 { 5072 btif_hl_thread_cleanup(); 5073 BTIF_TRACE_DEBUG("Exit hl_select_thread for btif_hl_signal_select_exit"); 5074 return 0; 5075 } 5076 } 5077 5078 btif_hl_select_monitor_callback(&curr_set, &org_set); 5079 max_org_s = btif_hl_update_maxfd(max_org_s); 5080 } 5081 else 5082 BTIF_TRACE_DEBUG("no data, select ret: %d\n", ret); 5083 } 5084 BTIF_TRACE_DEBUG("leaving hl_select_thread"); 5085 return 0; 5086} 5087 5088/******************************************************************************* 5089** 5090** Function create_thread 5091** 5092** Description creat a select loop 5093** 5094** Returns pthread_t 5095** 5096*******************************************************************************/ 5097static inline pthread_t create_thread(void *(*start_routine)(void *), void * arg){ 5098 BTIF_TRACE_DEBUG("create_thread: entered"); 5099 pthread_attr_t thread_attr; 5100 5101 pthread_attr_init(&thread_attr); 5102 pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_JOINABLE); 5103 pthread_t thread_id = -1; 5104 if ( pthread_create(&thread_id, &thread_attr, start_routine, arg)!=0 ) 5105 { 5106 BTIF_TRACE_ERROR("pthread_create : %s", strerror(errno)); 5107 return -1; 5108 } 5109 BTIF_TRACE_DEBUG("create_thread: thread created successfully"); 5110 return thread_id; 5111} 5112 5113/******************************************************************************* 5114** 5115** Function btif_hl_soc_thread_init 5116** 5117** Description HL select loop init function. 5118** 5119** Returns void 5120** 5121*******************************************************************************/ 5122void btif_hl_soc_thread_init(void){ 5123 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 5124 GKI_init_q(&soc_queue); 5125 select_thread_id = create_thread(btif_hl_select_thread, NULL); 5126} 5127/******************************************************************************* 5128** 5129** Function btif_hl_load_mdl_config 5130** 5131** Description load the MDL configuation from the application control block 5132** 5133** Returns BOOLEAN 5134** 5135*******************************************************************************/ 5136BOOLEAN btif_hl_load_mdl_config (UINT8 app_id, UINT8 buffer_size, 5137 tBTA_HL_MDL_CFG *p_mdl_buf ){ 5138 UINT8 app_idx; 5139 BOOLEAN result = FALSE; 5140 btif_hl_app_cb_t *p_acb; 5141 tBTA_HL_MDL_CFG *p; 5142 int i; 5143 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 5144 5145 if (btif_hl_find_app_idx(app_id, &app_idx)) 5146 { 5147 p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx); 5148 for (i=0, p=p_mdl_buf; i<buffer_size; i++, p++) 5149 { 5150 memcpy(p, &p_acb->mdl_cfg[i].base, sizeof(tBTA_HL_MDL_CFG)); 5151 } 5152 result = TRUE; 5153 } 5154 5155 BTIF_TRACE_DEBUG("result=%d", result); 5156 return result; 5157} 5158