1 /****************************************************************************** 2 * 3 * Copyright (C) 2003-2012 Broadcom Corporation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19 /****************************************************************************** 20 * 21 * This is the main implementation file for the BTA audio gateway. 22 * 23 ******************************************************************************/ 24 25 #include <string.h> 26 #include "bta_api.h" 27 #include "bta_sys.h" 28 #include "bta_ag_co.h" 29 #include "bta_ag_int.h" 30 #include "utl.h" 31 32 /***************************************************************************** 33 ** Constants and types 34 *****************************************************************************/ 35 #ifndef BTA_AG_DEBUG 36 #define BTA_AG_DEBUG FALSE 37 #endif 38 39 extern fixed_queue_t *btu_bta_alarm_queue; 40 41 #if BTA_AG_DEBUG == TRUE 42 static char *bta_ag_evt_str(UINT16 event, tBTA_AG_RES result); 43 static char *bta_ag_state_str(UINT8 state); 44 #endif 45 46 /* state machine states */ 47 enum 48 { 49 BTA_AG_INIT_ST, 50 BTA_AG_OPENING_ST, 51 BTA_AG_OPEN_ST, 52 BTA_AG_CLOSING_ST 53 }; 54 55 /* state machine action enumeration list */ 56 enum 57 { 58 BTA_AG_REGISTER, 59 BTA_AG_DEREGISTER, 60 BTA_AG_START_OPEN, 61 BTA_AG_RFC_DO_OPEN, 62 BTA_AG_RFC_DO_CLOSE, 63 BTA_AG_START_DEREG, 64 BTA_AG_START_CLOSE, 65 BTA_AG_RFC_OPEN, 66 BTA_AG_OPEN_FAIL, 67 BTA_AG_RFC_ACP_OPEN, 68 BTA_AG_RFC_CLOSE, 69 BTA_AG_RFC_FAIL, 70 BTA_AG_RFC_DATA, 71 BTA_AG_DISC_INT_RES, 72 BTA_AG_DISC_FAIL, 73 BTA_AG_DISC_ACP_RES, 74 BTA_AG_FREE_DB, 75 BTA_AG_SCO_CONN_OPEN, 76 BTA_AG_SCO_CONN_CLOSE, 77 BTA_AG_SCO_LISTEN, 78 BTA_AG_SCO_OPEN, 79 BTA_AG_SCO_CLOSE, 80 BTA_AG_SCO_SHUTDOWN, 81 BTA_AG_POST_SCO_OPEN, 82 BTA_AG_POST_SCO_CLOSE, 83 BTA_AG_SVC_CONN_OPEN, 84 BTA_AG_RESULT, 85 BTA_AG_SETCODEC, 86 BTA_AG_SEND_RING, 87 BTA_AG_CI_SCO_DATA, 88 BTA_AG_CI_RX_DATA, 89 BTA_AG_RCVD_SLC_READY, 90 BTA_AG_NUM_ACTIONS 91 }; 92 93 #define BTA_AG_IGNORE BTA_AG_NUM_ACTIONS 94 95 /* type for action functions */ 96 typedef void (*tBTA_AG_ACTION)(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data); 97 98 /* action functions */ 99 const tBTA_AG_ACTION bta_ag_action[] = 100 { 101 bta_ag_register, 102 bta_ag_deregister, 103 bta_ag_start_open, 104 bta_ag_rfc_do_open, 105 bta_ag_rfc_do_close, 106 bta_ag_start_dereg, 107 bta_ag_start_close, 108 bta_ag_rfc_open, 109 bta_ag_open_fail, 110 bta_ag_rfc_acp_open, 111 bta_ag_rfc_close, 112 bta_ag_rfc_fail, 113 bta_ag_rfc_data, 114 bta_ag_disc_int_res, 115 bta_ag_disc_fail, 116 bta_ag_disc_acp_res, 117 bta_ag_free_db, 118 bta_ag_sco_conn_open, 119 bta_ag_sco_conn_close, 120 bta_ag_sco_listen, 121 bta_ag_sco_open, 122 bta_ag_sco_close, 123 bta_ag_sco_shutdown, 124 bta_ag_post_sco_open, 125 bta_ag_post_sco_close, 126 bta_ag_svc_conn_open, 127 bta_ag_result, 128 bta_ag_setcodec, 129 bta_ag_send_ring, 130 bta_ag_ci_sco_data, 131 bta_ag_ci_rx_data, 132 bta_ag_rcvd_slc_ready 133 }; 134 135 /* state table information */ 136 #define BTA_AG_ACTIONS 2 /* number of actions */ 137 #define BTA_AG_NEXT_STATE 2 /* position of next state */ 138 #define BTA_AG_NUM_COLS 3 /* number of columns in state tables */ 139 140 /* state table for init state */ 141 const UINT8 bta_ag_st_init[][BTA_AG_NUM_COLS] = 142 { 143 /* Event Action 1 Action 2 Next state */ 144 /* API_REGISTER_EVT */ {BTA_AG_REGISTER, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 145 /* API_DEREGISTER_EVT */ {BTA_AG_DEREGISTER, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 146 /* API_OPEN_EVT */ {BTA_AG_START_OPEN, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 147 /* API_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 148 /* API_AUDIO_OPEN_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 149 /* API_AUDIO_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 150 /* API_RESULT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 151 /* API_SETCODEC_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 152 /* RFC_OPEN_EVT */ {BTA_AG_RFC_ACP_OPEN, BTA_AG_SCO_LISTEN, BTA_AG_OPEN_ST}, 153 /* RFC_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 154 /* RFC_SRV_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 155 /* RFC_DATA_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 156 /* SCO_OPEN_EVT */ {BTA_AG_SCO_CONN_OPEN, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 157 /* SCO_CLOSE_EVT */ {BTA_AG_SCO_CONN_CLOSE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 158 /* DISC_ACP_RES_EVT */ {BTA_AG_FREE_DB, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 159 /* DISC_INT_RES_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 160 /* DISC_OK_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 161 /* DISC_FAIL_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 162 /* CI_RX_WRITE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 163 /* RING_TOUT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 164 /* SVC_TOUT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 165 /* CI_SCO_DATA_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 166 /* CI_SLC_READY_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST} 167 }; 168 169 /* state table for opening state */ 170 const UINT8 bta_ag_st_opening[][BTA_AG_NUM_COLS] = 171 { 172 /* Event Action 1 Action 2 Next state */ 173 /* API_REGISTER_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 174 /* API_DEREGISTER_EVT */ {BTA_AG_RFC_DO_CLOSE, BTA_AG_START_DEREG, BTA_AG_CLOSING_ST}, 175 /* API_OPEN_EVT */ {BTA_AG_OPEN_FAIL, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 176 /* API_CLOSE_EVT */ {BTA_AG_RFC_DO_CLOSE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 177 /* API_AUDIO_OPEN_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 178 /* API_AUDIO_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 179 /* API_RESULT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 180 /* API_SETCODEC_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 181 /* RFC_OPEN_EVT */ {BTA_AG_RFC_OPEN, BTA_AG_SCO_LISTEN, BTA_AG_OPEN_ST}, 182 /* RFC_CLOSE_EVT */ {BTA_AG_RFC_FAIL, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 183 /* RFC_SRV_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 184 /* RFC_DATA_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 185 /* SCO_OPEN_EVT */ {BTA_AG_SCO_CONN_OPEN, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 186 /* SCO_CLOSE_EVT */ {BTA_AG_SCO_CONN_CLOSE, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 187 /* DISC_ACP_RES_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 188 /* DISC_INT_RES_EVT */ {BTA_AG_DISC_INT_RES, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 189 /* DISC_OK_EVT */ {BTA_AG_RFC_DO_OPEN, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 190 /* DISC_FAIL_EVT */ {BTA_AG_DISC_FAIL, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 191 /* CI_RX_WRITE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 192 /* RING_TOUT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 193 /* SVC_TOUT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 194 /* CI_SCO_DATA_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST}, 195 /* CI_SLC_READY_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST} 196 }; 197 198 /* state table for open state */ 199 const UINT8 bta_ag_st_open[][BTA_AG_NUM_COLS] = 200 { 201 /* Event Action 1 Action 2 Next state */ 202 /* API_REGISTER_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPEN_ST}, 203 /* API_DEREGISTER_EVT */ {BTA_AG_START_CLOSE, BTA_AG_START_DEREG, BTA_AG_CLOSING_ST}, 204 /* API_OPEN_EVT */ {BTA_AG_OPEN_FAIL, BTA_AG_IGNORE, BTA_AG_OPEN_ST}, 205 /* API_CLOSE_EVT */ {BTA_AG_START_CLOSE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 206 /* API_AUDIO_OPEN_EVT */ {BTA_AG_SCO_OPEN, BTA_AG_IGNORE, BTA_AG_OPEN_ST}, 207 /* API_AUDIO_CLOSE_EVT */ {BTA_AG_SCO_CLOSE, BTA_AG_IGNORE, BTA_AG_OPEN_ST}, 208 /* API_RESULT_EVT */ {BTA_AG_RESULT, BTA_AG_IGNORE, BTA_AG_OPEN_ST}, 209 /* API_SETCODEC_EVT */ {BTA_AG_SETCODEC, BTA_AG_IGNORE, BTA_AG_OPEN_ST}, 210 /* RFC_OPEN_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPEN_ST}, 211 /* RFC_CLOSE_EVT */ {BTA_AG_RFC_CLOSE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 212 /* RFC_SRV_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPEN_ST}, 213 /* RFC_DATA_EVT */ {BTA_AG_RFC_DATA, BTA_AG_IGNORE, BTA_AG_OPEN_ST}, 214 /* SCO_OPEN_EVT */ {BTA_AG_SCO_CONN_OPEN, BTA_AG_POST_SCO_OPEN, BTA_AG_OPEN_ST}, 215 /* SCO_CLOSE_EVT */ {BTA_AG_SCO_CONN_CLOSE, BTA_AG_POST_SCO_CLOSE, BTA_AG_OPEN_ST}, 216 /* DISC_ACP_RES_EVT */ {BTA_AG_DISC_ACP_RES, BTA_AG_IGNORE, BTA_AG_OPEN_ST}, 217 /* DISC_INT_RES_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPEN_ST}, 218 /* DISC_OK_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPEN_ST}, 219 /* DISC_FAIL_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPEN_ST}, 220 /* CI_RX_WRITE_EVT */ {BTA_AG_CI_RX_DATA, BTA_AG_IGNORE, BTA_AG_OPEN_ST}, 221 /* RING_TOUT_EVT */ {BTA_AG_SEND_RING, BTA_AG_IGNORE, BTA_AG_OPEN_ST}, 222 /* SVC_TOUT_EVT */ {BTA_AG_START_CLOSE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 223 /* CI_SCO_DATA_EVT */ {BTA_AG_CI_SCO_DATA, BTA_AG_IGNORE, BTA_AG_OPEN_ST}, 224 /* CI_SLC_READY_EVT */ {BTA_AG_RCVD_SLC_READY, BTA_AG_IGNORE, BTA_AG_OPEN_ST} 225 }; 226 227 /* state table for closing state */ 228 const UINT8 bta_ag_st_closing[][BTA_AG_NUM_COLS] = 229 { 230 /* Event Action 1 Action 2 Next state */ 231 /* API_REGISTER_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 232 /* API_DEREGISTER_EVT */ {BTA_AG_START_DEREG, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 233 /* API_OPEN_EVT */ {BTA_AG_OPEN_FAIL, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 234 /* API_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 235 /* API_AUDIO_OPEN_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 236 /* API_AUDIO_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 237 /* API_RESULT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 238 /* API_SETCODEC_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 239 /* RFC_OPEN_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 240 /* RFC_CLOSE_EVT */ {BTA_AG_RFC_CLOSE, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 241 /* RFC_SRV_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 242 /* RFC_DATA_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 243 /* SCO_OPEN_EVT */ {BTA_AG_SCO_CONN_OPEN, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 244 /* SCO_CLOSE_EVT */ {BTA_AG_SCO_CONN_CLOSE, BTA_AG_POST_SCO_CLOSE, BTA_AG_CLOSING_ST}, 245 /* DISC_ACP_RES_EVT */ {BTA_AG_FREE_DB, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 246 /* DISC_INT_RES_EVT */ {BTA_AG_FREE_DB, BTA_AG_IGNORE, BTA_AG_INIT_ST}, 247 /* DISC_OK_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 248 /* DISC_FAIL_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 249 /* CI_RX_WRITE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 250 /* RING_TOUT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 251 /* SVC_TOUT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 252 /* CI_SCO_DATA_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}, 253 /* CI_SLC_READY_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST} 254 }; 255 256 /* type for state table */ 257 typedef const UINT8 (*tBTA_AG_ST_TBL)[BTA_AG_NUM_COLS]; 258 259 /* state table */ 260 const tBTA_AG_ST_TBL bta_ag_st_tbl[] = 261 { 262 bta_ag_st_init, 263 bta_ag_st_opening, 264 bta_ag_st_open, 265 bta_ag_st_closing 266 }; 267 268 /***************************************************************************** 269 ** Global data 270 *****************************************************************************/ 271 272 /* AG control block */ 273 #if BTA_DYNAMIC_MEMORY == FALSE 274 tBTA_AG_CB bta_ag_cb; 275 #endif 276 277 /******************************************************************************* 278 ** 279 ** Function bta_ag_scb_alloc 280 ** 281 ** Description Allocate an AG service control block. 282 ** 283 ** 284 ** Returns pointer to the scb, or NULL if none could be allocated. 285 ** 286 *******************************************************************************/ 287 static tBTA_AG_SCB *bta_ag_scb_alloc(void) 288 { 289 tBTA_AG_SCB *p_scb = &bta_ag_cb.scb[0]; 290 int i; 291 292 for (i = 0; i < BTA_AG_NUM_SCB; i++, p_scb++) 293 { 294 if (!p_scb->in_use) 295 { 296 /* initialize variables */ 297 p_scb->in_use = TRUE; 298 p_scb->sco_idx = BTM_INVALID_SCO_INDEX; 299 #if (BTM_WBS_INCLUDED == TRUE ) 300 p_scb->codec_updated = FALSE; 301 p_scb->peer_codecs = BTA_AG_CODEC_CVSD; 302 p_scb->sco_codec = BTA_AG_CODEC_CVSD; 303 #endif 304 /* set up timers */ 305 p_scb->ring_timer = alarm_new("bta_ag.scb_ring_timer"); 306 p_scb->collision_timer = alarm_new("bta_ag.scb_collision_timer"); 307 #if (BTM_WBS_INCLUDED == TRUE) 308 p_scb->codec_negotiation_timer = 309 alarm_new("bta_ag.scb_codec_negotiation_timer"); 310 /* set eSCO mSBC setting to T2 as the preferred */ 311 p_scb->codec_msbc_settings = BTA_AG_SCO_MSBC_SETTINGS_T2; 312 #endif 313 APPL_TRACE_DEBUG("bta_ag_scb_alloc %d", bta_ag_scb_to_idx(p_scb)); 314 break; 315 } 316 } 317 318 if (i == BTA_AG_NUM_SCB) 319 { 320 /* out of scbs */ 321 p_scb = NULL; 322 APPL_TRACE_WARNING("Out of ag scbs"); 323 } 324 return p_scb; 325 } 326 327 /******************************************************************************* 328 ** 329 ** Function bta_ag_scb_dealloc 330 ** 331 ** Description Deallocate a service control block. 332 ** 333 ** 334 ** Returns void 335 ** 336 *******************************************************************************/ 337 void bta_ag_scb_dealloc(tBTA_AG_SCB *p_scb) 338 { 339 UINT8 idx; 340 BOOLEAN allocated = FALSE; 341 342 APPL_TRACE_DEBUG("bta_ag_scb_dealloc %d", bta_ag_scb_to_idx(p_scb)); 343 344 /* stop and free timers */ 345 alarm_free(p_scb->ring_timer); 346 #if (BTM_WBS_INCLUDED == TRUE) 347 alarm_free(p_scb->codec_negotiation_timer); 348 #endif 349 alarm_free(p_scb->collision_timer); 350 351 /* initialize control block */ 352 memset(p_scb, 0, sizeof(tBTA_AG_SCB)); 353 p_scb->sco_idx = BTM_INVALID_SCO_INDEX; 354 355 /* If all scbs are deallocated, callback with disable event */ 356 if (!bta_sys_is_register (BTA_ID_AG)) 357 { 358 for (idx = 0; idx < BTA_AG_NUM_SCB; idx++) 359 { 360 if (bta_ag_cb.scb[idx].in_use) 361 { 362 allocated = TRUE; 363 break; 364 } 365 } 366 367 if (!allocated) 368 { 369 (*bta_ag_cb.p_cback)(BTA_AG_DISABLE_EVT, NULL); 370 } 371 } 372 373 } 374 375 /******************************************************************************* 376 ** 377 ** Function bta_ag_scb_to_idx 378 ** 379 ** Description Given a pointer to an scb, return its index. 380 ** 381 ** 382 ** Returns Index of scb. 383 ** 384 *******************************************************************************/ 385 UINT16 bta_ag_scb_to_idx(tBTA_AG_SCB *p_scb) 386 { 387 /* use array arithmetic to determine index */ 388 return ((UINT16) (p_scb - bta_ag_cb.scb)) + 1; 389 } 390 391 /******************************************************************************* 392 ** 393 ** Function bta_ag_scb_by_idx 394 ** 395 ** Description Given an scb index return pointer to scb. 396 ** 397 ** 398 ** Returns Pointer to scb or NULL if not allocated. 399 ** 400 *******************************************************************************/ 401 tBTA_AG_SCB *bta_ag_scb_by_idx(UINT16 idx) 402 { 403 tBTA_AG_SCB *p_scb; 404 405 /* verify index */ 406 if (idx > 0 && idx <= BTA_AG_NUM_SCB) 407 { 408 p_scb = &bta_ag_cb.scb[idx - 1]; 409 if (!p_scb->in_use) 410 { 411 p_scb = NULL; 412 APPL_TRACE_WARNING("ag scb idx %d not allocated", idx); 413 } 414 } 415 else 416 { 417 p_scb = NULL; 418 APPL_TRACE_DEBUG("ag scb idx %d out of range", idx); 419 } 420 return p_scb; 421 } 422 423 /******************************************************************************* 424 ** 425 ** Function bta_ag_service_to_idx 426 ** 427 ** Description Given a BTA service mask convert to profile index. 428 ** 429 ** 430 ** Returns Profile ndex of scb. 431 ** 432 *******************************************************************************/ 433 UINT8 bta_ag_service_to_idx(tBTA_SERVICE_MASK services) 434 { 435 if (services & BTA_HFP_SERVICE_MASK) 436 { 437 return BTA_AG_HFP; 438 } 439 else 440 { 441 return BTA_AG_HSP; 442 } 443 } 444 445 /******************************************************************************* 446 ** 447 ** Function bta_ag_idx_by_bdaddr 448 ** 449 ** Description Find SCB associated with peer BD address. 450 ** 451 ** 452 ** Returns Index of SCB or zero if none found. 453 ** 454 *******************************************************************************/ 455 UINT16 bta_ag_idx_by_bdaddr(BD_ADDR peer_addr) 456 { 457 tBTA_AG_SCB *p_scb = &bta_ag_cb.scb[0]; 458 UINT16 i; 459 460 if (peer_addr != NULL) 461 { 462 for (i = 0; i < BTA_AG_NUM_SCB; i++, p_scb++) 463 { 464 if (p_scb->in_use && !bdcmp(peer_addr, p_scb->peer_addr)) 465 { 466 return (i + 1); 467 } 468 } 469 } 470 471 /* no scb found */ 472 APPL_TRACE_WARNING("No ag scb for peer addr"); 473 return 0; 474 } 475 476 /******************************************************************************* 477 ** 478 ** Function bta_ag_other_scb_open 479 ** 480 ** Description Check whether any other scb is in open state. 481 ** 482 ** 483 ** Returns TRUE if another scb is in open state, FALSE otherwise. 484 ** 485 *******************************************************************************/ 486 BOOLEAN bta_ag_other_scb_open(tBTA_AG_SCB *p_curr_scb) 487 { 488 tBTA_AG_SCB *p_scb = &bta_ag_cb.scb[0]; 489 int i; 490 491 for (i = 0; i < BTA_AG_NUM_SCB; i++, p_scb++) 492 { 493 if (p_scb->in_use && p_scb != p_curr_scb && p_scb->state == BTA_AG_OPEN_ST) 494 { 495 return TRUE; 496 } 497 } 498 499 /* no other scb found */ 500 APPL_TRACE_DEBUG("No other ag scb open"); 501 return FALSE; 502 } 503 504 /******************************************************************************* 505 ** 506 ** Function bta_ag_scb_open 507 ** 508 ** Description Check whether given scb is in open state. 509 ** 510 ** 511 ** Returns TRUE if scb is in open state, FALSE otherwise. 512 ** 513 *******************************************************************************/ 514 BOOLEAN bta_ag_scb_open(tBTA_AG_SCB *p_curr_scb) 515 { 516 if (p_curr_scb && p_curr_scb->in_use && p_curr_scb->state == BTA_AG_OPEN_ST) 517 { 518 return TRUE; 519 } 520 521 return FALSE; 522 } 523 524 /******************************************************************************* 525 ** 526 ** Function bta_ag_get_other_idle_scb 527 ** 528 ** Description Return other scb if it is in INIT st. 529 ** 530 ** 531 ** Returns Pointer to other scb if INIT st, NULL otherwise. 532 ** 533 *******************************************************************************/ 534 tBTA_AG_SCB *bta_ag_get_other_idle_scb (tBTA_AG_SCB *p_curr_scb) 535 { 536 tBTA_AG_SCB *p_scb = &bta_ag_cb.scb[0]; 537 UINT8 xx; 538 539 for (xx = 0; xx < BTA_AG_NUM_SCB; xx++, p_scb++) 540 { 541 if (p_scb->in_use && (p_scb != p_curr_scb) && (p_scb->state == BTA_AG_INIT_ST)) 542 { 543 return p_scb; 544 } 545 } 546 547 /* no other scb found */ 548 APPL_TRACE_DEBUG("bta_ag_get_other_idle_scb: No idle AG scb"); 549 return NULL; 550 } 551 552 /******************************************************************************* 553 ** 554 ** Function bta_ag_collision_timer_cback 555 ** 556 ** Description AG connection collision timer callback 557 ** 558 ** 559 ** Returns void 560 ** 561 *******************************************************************************/ 562 static void bta_ag_collision_timer_cback(void *data) 563 { 564 tBTA_AG_SCB *p_scb = (tBTA_AG_SCB *)data; 565 566 APPL_TRACE_DEBUG("%s", __func__); 567 568 /* If the peer haven't opened AG connection */ 569 /* we will restart opening process. */ 570 bta_ag_resume_open(p_scb); 571 } 572 573 /******************************************************************************* 574 ** 575 ** Function bta_ag_collision_cback 576 ** 577 ** Description Get notified about collision. 578 ** 579 ** 580 ** Returns void 581 ** 582 *******************************************************************************/ 583 void bta_ag_collision_cback (tBTA_SYS_CONN_STATUS status, UINT8 id, 584 UINT8 app_id, BD_ADDR peer_addr) 585 { 586 UINT16 handle; 587 tBTA_AG_SCB *p_scb; 588 UNUSED(status); 589 UNUSED(app_id); 590 591 /* Check if we have opening scb for the peer device. */ 592 handle = bta_ag_idx_by_bdaddr (peer_addr); 593 p_scb = bta_ag_scb_by_idx (handle); 594 595 if (p_scb && (p_scb->state == BTA_AG_OPENING_ST)) 596 { 597 if (id == BTA_ID_SYS) /* ACL collision */ 598 { 599 APPL_TRACE_WARNING ("AG found collision (ACL) ..."); 600 } 601 else if (id == BTA_ID_AG) /* RFCOMM collision */ 602 { 603 APPL_TRACE_WARNING ("AG found collision (RFCOMM) ..."); 604 } 605 else 606 { 607 APPL_TRACE_WARNING ("AG found collision (\?\?\?) ..."); 608 } 609 610 p_scb->state = BTA_AG_INIT_ST; 611 612 /* Cancel SDP if it had been started. */ 613 if(p_scb->p_disc_db) 614 { 615 (void)SDP_CancelServiceSearch (p_scb->p_disc_db); 616 bta_ag_free_db(p_scb, NULL); 617 } 618 619 /* reopen registered servers */ 620 /* Collision may be detected before or after we close servers. */ 621 if (bta_ag_is_server_closed (p_scb)) 622 bta_ag_start_servers(p_scb, p_scb->reg_services); 623 624 /* Start timer to han */ 625 alarm_set_on_queue(p_scb->collision_timer, BTA_AG_COLLISION_TIMEOUT_MS, 626 bta_ag_collision_timer_cback, p_scb, 627 btu_bta_alarm_queue); 628 } 629 } 630 631 /******************************************************************************* 632 ** 633 ** Function bta_ag_resume_open 634 ** 635 ** Description Resume opening process. 636 ** 637 ** 638 ** Returns void 639 ** 640 *******************************************************************************/ 641 void bta_ag_resume_open (tBTA_AG_SCB *p_scb) 642 { 643 if (p_scb) 644 { 645 APPL_TRACE_DEBUG ("bta_ag_resume_open, Handle(%d)", bta_ag_scb_to_idx(p_scb)); 646 647 /* resume opening process. */ 648 if (p_scb->state == BTA_AG_INIT_ST) 649 { 650 p_scb->state = BTA_AG_OPENING_ST; 651 bta_ag_start_open (p_scb, NULL); 652 } 653 } 654 else 655 { 656 APPL_TRACE_ERROR ("bta_ag_resume_open, Null p_scb"); 657 } 658 } 659 660 /******************************************************************************* 661 ** 662 ** Function bta_ag_api_enable 663 ** 664 ** Description Handle an API enable event. 665 ** 666 ** 667 ** Returns void 668 ** 669 *******************************************************************************/ 670 static void bta_ag_api_enable(tBTA_AG_DATA *p_data) 671 { 672 /* initialize control block */ 673 for (size_t i = 0; i < BTA_AG_NUM_SCB; i++) { 674 alarm_free(bta_ag_cb.scb[i].ring_timer); 675 #if (BTM_WBS_INCLUDED == TRUE) 676 alarm_free(bta_ag_cb.scb[i].codec_negotiation_timer); 677 #endif 678 alarm_free(bta_ag_cb.scb[i].collision_timer); 679 } 680 memset(&bta_ag_cb, 0, sizeof(tBTA_AG_CB)); 681 682 /* store callback function */ 683 bta_ag_cb.p_cback = p_data->api_enable.p_cback; 684 bta_ag_cb.parse_mode = p_data->api_enable.parse_mode; 685 686 /* call init call-out */ 687 bta_ag_co_init(); 688 689 bta_sys_collision_register (BTA_ID_AG, bta_ag_collision_cback); 690 691 /* call callback with enable event */ 692 (*bta_ag_cb.p_cback)(BTA_AG_ENABLE_EVT, NULL); 693 } 694 695 /******************************************************************************* 696 ** 697 ** Function bta_ag_api_disable 698 ** 699 ** Description Handle an API disable event. 700 ** 701 ** 702 ** Returns void 703 ** 704 *******************************************************************************/ 705 static void bta_ag_api_disable(tBTA_AG_DATA *p_data) 706 { 707 /* deregister all scbs in use */ 708 tBTA_AG_SCB *p_scb = &bta_ag_cb.scb[0]; 709 BOOLEAN do_dereg = FALSE; 710 int i; 711 712 if (!bta_sys_is_register (BTA_ID_AG)) 713 { 714 APPL_TRACE_ERROR("BTA AG is already disabled, ignoring ..."); 715 return; 716 } 717 718 /* De-register with BTA system manager */ 719 bta_sys_deregister(BTA_ID_AG); 720 721 for (i = 0; i < BTA_AG_NUM_SCB; i++, p_scb++) 722 { 723 if (p_scb->in_use) 724 { 725 bta_ag_sm_execute(p_scb, BTA_AG_API_DEREGISTER_EVT, p_data); 726 do_dereg = TRUE; 727 } 728 } 729 730 if (!do_dereg) 731 { 732 /* Done, send callback evt to app */ 733 (*bta_ag_cb.p_cback)(BTA_AG_DISABLE_EVT, NULL); 734 } 735 736 bta_sys_collision_register (BTA_ID_AG, NULL); 737 } 738 739 /******************************************************************************* 740 ** 741 ** Function bta_ag_api_register 742 ** 743 ** Description Handle an API event registers a new service. 744 ** 745 ** 746 ** Returns void 747 ** 748 *******************************************************************************/ 749 static void bta_ag_api_register(tBTA_AG_DATA *p_data) 750 { 751 tBTA_AG_SCB *p_scb; 752 tBTA_AG_REGISTER reg; 753 754 /* allocate an scb */ 755 if ((p_scb = bta_ag_scb_alloc()) != NULL) 756 { 757 APPL_TRACE_DEBUG("bta_ag_api_register: p_scb 0x%08x ", p_scb); 758 bta_ag_sm_execute(p_scb, p_data->hdr.event, p_data); 759 } 760 else 761 { 762 reg.status = BTA_AG_FAIL_RESOURCES; 763 (*bta_ag_cb.p_cback)(BTA_AG_REGISTER_EVT, (tBTA_AG *) ®); 764 } 765 } 766 767 /******************************************************************************* 768 ** 769 ** Function bta_ag_api_result 770 ** 771 ** Description Handle an API result event. 772 ** 773 ** 774 ** Returns void 775 ** 776 *******************************************************************************/ 777 static void bta_ag_api_result(tBTA_AG_DATA *p_data) 778 { 779 tBTA_AG_SCB *p_scb; 780 int i; 781 782 if (p_data->hdr.layer_specific != BTA_AG_HANDLE_ALL) 783 { 784 if ((p_scb = bta_ag_scb_by_idx(p_data->hdr.layer_specific)) != NULL) 785 { 786 APPL_TRACE_DEBUG("bta_ag_api_result: p_scb 0x%08x ", p_scb); 787 bta_ag_sm_execute(p_scb, BTA_AG_API_RESULT_EVT, p_data); 788 } 789 } 790 else 791 { 792 for (i = 0, p_scb = &bta_ag_cb.scb[0]; i < BTA_AG_NUM_SCB; i++, p_scb++) 793 { 794 if (p_scb->in_use && p_scb->svc_conn) 795 { 796 APPL_TRACE_DEBUG("bta_ag_api_result p_scb 0x%08x ", p_scb); 797 bta_ag_sm_execute(p_scb, BTA_AG_API_RESULT_EVT, p_data); 798 } 799 } 800 } 801 } 802 803 /******************************************************************************* 804 ** 805 ** Function bta_ag_sm_execute 806 ** 807 ** Description State machine event handling function for AG 808 ** 809 ** 810 ** Returns void 811 ** 812 *******************************************************************************/ 813 void bta_ag_sm_execute(tBTA_AG_SCB *p_scb, UINT16 event, tBTA_AG_DATA *p_data) 814 { 815 tBTA_AG_ST_TBL state_table; 816 UINT8 action; 817 int i; 818 819 #if BTA_AG_DEBUG == TRUE 820 UINT16 in_event = event; 821 UINT8 in_state = p_scb->state; 822 823 /* Ignore displaying of AT results when not connected (Ignored in state machine) */ 824 if (in_event != BTA_AG_API_RESULT_EVT || p_scb->state == BTA_AG_OPEN_ST) 825 { 826 APPL_TRACE_EVENT("AG evt (hdl 0x%04x): State %d (%s), Event 0x%04x (%s)", 827 bta_ag_scb_to_idx(p_scb), 828 p_scb->state, bta_ag_state_str(p_scb->state), 829 event, bta_ag_evt_str(event, p_data->api_result.result)); 830 } 831 #else 832 APPL_TRACE_EVENT("AG evt (hdl 0x%04x): State %d, Event 0x%04x", 833 bta_ag_scb_to_idx(p_scb), p_scb->state, event); 834 #endif 835 836 event &= 0x00FF; 837 if (event >= (BTA_AG_MAX_EVT & 0x00FF)) 838 { 839 APPL_TRACE_ERROR("AG evt out of range, ignoring..."); 840 return; 841 } 842 843 /* look up the state table for the current state */ 844 state_table = bta_ag_st_tbl[p_scb->state]; 845 846 /* set next state */ 847 p_scb->state = state_table[event][BTA_AG_NEXT_STATE]; 848 849 /* execute action functions */ 850 for (i = 0; i < BTA_AG_ACTIONS; i++) 851 { 852 if ((action = state_table[event][i]) != BTA_AG_IGNORE) 853 { 854 (*bta_ag_action[action])(p_scb, p_data); 855 } 856 else 857 { 858 break; 859 } 860 } 861 #if BTA_AG_DEBUG == TRUE 862 if (p_scb->state != in_state) 863 { 864 APPL_TRACE_EVENT("BTA AG State Change: [%s] -> [%s] after Event [%s]", 865 bta_ag_state_str(in_state), 866 bta_ag_state_str(p_scb->state), 867 bta_ag_evt_str(in_event, p_data->api_result.result)); 868 } 869 #endif 870 } 871 872 /******************************************************************************* 873 ** 874 ** Function bta_ag_hdl_event 875 ** 876 ** Description Data gateway main event handling function. 877 ** 878 ** 879 ** Returns BOOLEAN 880 ** 881 *******************************************************************************/ 882 BOOLEAN bta_ag_hdl_event(BT_HDR *p_msg) 883 { 884 tBTA_AG_SCB *p_scb; 885 886 APPL_TRACE_DEBUG("bta_ag_hdl_event: Event 0x%04x ", p_msg->event); 887 switch (p_msg->event) 888 { 889 /* handle enable event */ 890 case BTA_AG_API_ENABLE_EVT: 891 bta_ag_api_enable((tBTA_AG_DATA *) p_msg); 892 break; 893 894 /* handle disable event */ 895 case BTA_AG_API_DISABLE_EVT: 896 bta_ag_api_disable((tBTA_AG_DATA *) p_msg); 897 break; 898 899 /* handle register event */ 900 case BTA_AG_API_REGISTER_EVT: 901 bta_ag_api_register((tBTA_AG_DATA *) p_msg); 902 break; 903 904 /* handle result event */ 905 case BTA_AG_API_RESULT_EVT: 906 bta_ag_api_result((tBTA_AG_DATA *) p_msg); 907 break; 908 909 /* all others reference scb by handle */ 910 default: 911 if ((p_scb = bta_ag_scb_by_idx(p_msg->layer_specific)) != NULL) 912 { 913 APPL_TRACE_DEBUG("bta_ag_hdl_event: p_scb 0x%08x ", p_scb); 914 bta_ag_sm_execute(p_scb, p_msg->event, (tBTA_AG_DATA *) p_msg); 915 } 916 break; 917 } 918 return TRUE; 919 } 920 921 #if BTA_AG_DEBUG == TRUE 922 static char *bta_ag_evt_str(UINT16 event, tBTA_AG_RES result) 923 { 924 switch (event) 925 { 926 case BTA_AG_API_REGISTER_EVT: 927 return "Register Request"; 928 case BTA_AG_API_DEREGISTER_EVT: 929 return "Deregister Request"; 930 case BTA_AG_API_OPEN_EVT: 931 return "Open SLC Request"; 932 case BTA_AG_API_CLOSE_EVT: 933 return "Close SLC Request"; 934 case BTA_AG_API_AUDIO_OPEN_EVT: 935 return "Open Audio Request"; 936 case BTA_AG_API_AUDIO_CLOSE_EVT: 937 return "Close Audio Request"; 938 case BTA_AG_API_RESULT_EVT: 939 switch (result) 940 { 941 case BTA_AG_SPK_RES: return ("AT Result BTA_AG_SPK_RES"); 942 case BTA_AG_MIC_RES: return ("AT Result BTA_AG_MIC_RES"); 943 case BTA_AG_INBAND_RING_RES: return ("AT Result BTA_AG_INBAND_RING_RES"); 944 case BTA_AG_CIND_RES: return ("AT Result BTA_AG_CIND_RES"); 945 case BTA_AG_BINP_RES: return ("AT Result BTA_AG_BINP_RES"); 946 case BTA_AG_IND_RES: return ("AT Result BTA_AG_IND_RES"); 947 case BTA_AG_BVRA_RES: return ("AT Result BTA_AG_BVRA_RES"); 948 case BTA_AG_CNUM_RES: return ("AT Result BTA_AG_CNUM_RES"); 949 case BTA_AG_BTRH_RES: return ("AT Result BTA_AG_BTRH_RES"); 950 case BTA_AG_CLCC_RES: return ("AT Result BTA_AG_CLCC_RES"); 951 case BTA_AG_COPS_RES: return ("AT Result BTA_AG_COPS_RES"); 952 case BTA_AG_IN_CALL_RES: return ("AT Result BTA_AG_IN_CALL_RES"); 953 case BTA_AG_IN_CALL_CONN_RES: return ("AT Result BTA_AG_IN_CALL_CONN_RES"); 954 case BTA_AG_CALL_WAIT_RES: return ("AT Result BTA_AG_CALL_WAIT_RES"); 955 case BTA_AG_OUT_CALL_ORIG_RES: return ("AT Result BTA_AG_OUT_CALL_ORIG_RES"); 956 case BTA_AG_OUT_CALL_ALERT_RES: return ("AT Result BTA_AG_OUT_CALL_ALERT_RES"); 957 case BTA_AG_OUT_CALL_CONN_RES: return ("AT Result BTA_AG_OUT_CALL_CONN_RES"); 958 case BTA_AG_CALL_CANCEL_RES: return ("AT Result BTA_AG_CALL_CANCEL_RES"); 959 case BTA_AG_END_CALL_RES: return ("AT Result BTA_AG_END_CALL_RES"); 960 case BTA_AG_UNAT_RES: return ("AT Result BTA_AG_UNAT_RES"); 961 default: return ("Unknown AG Result"); 962 } 963 case BTA_AG_API_SETCODEC_EVT: 964 return "Set Codec Request"; 965 case BTA_AG_RFC_OPEN_EVT: 966 return "RFC Opened"; 967 case BTA_AG_RFC_CLOSE_EVT: 968 return "RFC Closed"; 969 case BTA_AG_RFC_SRV_CLOSE_EVT: 970 return "RFC SRV Closed"; 971 case BTA_AG_RFC_DATA_EVT: 972 return "RFC Data"; 973 case BTA_AG_SCO_OPEN_EVT: 974 return "Audio Opened"; 975 case BTA_AG_SCO_CLOSE_EVT: 976 return "Audio Closed"; 977 case BTA_AG_DISC_ACP_RES_EVT: 978 return "Discovery ACP Result"; 979 case BTA_AG_DISC_INT_RES_EVT: 980 return "Discovery INT Result"; 981 case BTA_AG_DISC_OK_EVT: 982 return "Discovery OK"; 983 case BTA_AG_DISC_FAIL_EVT: 984 return "Discovery Failed"; 985 case BTA_AG_CI_RX_WRITE_EVT: 986 return "CI RX Write"; 987 case BTA_AG_RING_TIMEOUT_EVT: 988 return "Ring Timeout"; 989 case BTA_AG_SVC_TIMEOUT_EVT: 990 return "Service Timeout"; 991 case BTA_AG_API_ENABLE_EVT: 992 return "Enable AG"; 993 case BTA_AG_API_DISABLE_EVT: 994 return "Disable AG"; 995 case BTA_AG_CI_SCO_DATA_EVT: 996 return "SCO data Callin"; 997 case BTA_AG_CI_SLC_READY_EVT: 998 return "SLC Ready Callin"; 999 default: 1000 return "Unknown AG Event"; 1001 } 1002 } 1003 1004 static char *bta_ag_state_str(UINT8 state) 1005 { 1006 switch (state) 1007 { 1008 case BTA_AG_INIT_ST: 1009 return "Initial"; 1010 case BTA_AG_OPENING_ST: 1011 return "Opening"; 1012 case BTA_AG_OPEN_ST: 1013 return "Open"; 1014 case BTA_AG_CLOSING_ST: 1015 return "Closing"; 1016 default: 1017 return "Unknown AG State"; 1018 } 1019 } 1020 1021 #endif 1022
