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