1 /******************************************************************************
2 *
3 * Copyright (C) 2004-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 advanced audio/video.
22 *
23 ******************************************************************************/
24
25 #include <assert.h>
26 #include <string.h>
27
28 #include "common/bt_target.h"
29 #include "common/bt_trace.h"
30 #include "osi/allocator.h"
31
32 #if defined(BTA_AV_INCLUDED) && (BTA_AV_INCLUDED == TRUE)
33 #include "bta_av_int.h"
34 #include "bta/utl.h"
35 #include "stack/l2c_api.h"
36 #include "stack/l2cdefs.h"
37 #include "bta/bta_av_co.h"
38 #include "stack/a2d_api.h"
39 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
40 #include "bta/bta_ar_api.h"
41 #endif
42 #include "osi/osi.h"
43
44 /*****************************************************************************
45 ** Constants and types
46 *****************************************************************************/
47
48 /* AVDTP protocol timeout values */
49 #define BTIF_AVK_SERVICE_NAME "Advanced Audio Sink"
50
51 #ifndef BTA_AV_RET_TOUT
52 #define BTA_AV_RET_TOUT 4
53 #endif
54
55 #ifndef BTA_AV_SIG_TOUT
56 #define BTA_AV_SIG_TOUT 4
57 #endif
58
59 #ifndef BTA_AV_IDLE_TOUT
60 #define BTA_AV_IDLE_TOUT 10
61 #endif
62
63 /* the delay time in milliseconds to retry role switch */
64 #ifndef BTA_AV_RS_TIME_VAL
65 #define BTA_AV_RS_TIME_VAL 1000
66 #endif
67
68 /* state machine states */
69 enum {
70 BTA_AV_INIT_ST,
71 BTA_AV_OPEN_ST
72 };
73
74 /* state machine action enumeration list */
75 enum {
76 BTA_AV_DISABLE,
77 BTA_AV_RC_OPENED,
78 BTA_AV_RC_REMOTE_CMD,
79 BTA_AV_RC_VENDOR_CMD,
80 BTA_AV_RC_VENDOR_RSP,
81 BTA_AV_RC_FREE_RSP,
82 BTA_AV_RC_FREE_MSG,
83 BTA_AV_RC_META_RSP,
84 BTA_AV_RC_MSG,
85 BTA_AV_RC_CLOSE,
86 BTA_AV_NUM_ACTIONS
87 };
88
89 #define BTA_AV_IGNORE BTA_AV_NUM_ACTIONS
90
91 /* type for action functions */
92 typedef void (*tBTA_AV_ACTION)(tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data);
93
94 /* action functions */
95 const tBTA_AV_ACTION bta_av_action[] = {
96 bta_av_disable,
97 bta_av_rc_opened,
98 bta_av_rc_remote_cmd,
99 bta_av_rc_vendor_cmd,
100 bta_av_rc_vendor_rsp,
101 bta_av_rc_free_rsp,
102 bta_av_rc_free_msg,
103 bta_av_rc_meta_rsp,
104 bta_av_rc_msg,
105 bta_av_rc_close,
106 NULL
107 };
108
109 /* state table information */
110 #define BTA_AV_ACTION_COL 0 /* position of actions */
111 #define BTA_AV_NEXT_STATE 1 /* position of next state */
112 #define BTA_AV_NUM_COLS 2 /* number of columns in state tables */
113
114 /* state table for init state */
115 static const UINT8 bta_av_st_init[][BTA_AV_NUM_COLS] = {
116 /* Event Action 1 Next state */
117 /* API_DISABLE_EVT */ {BTA_AV_DISABLE, BTA_AV_INIT_ST },
118 /* API_REMOTE_CMD_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
119 /* API_VENDOR_CMD_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
120 /* API_VENDOR_RSP_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
121 /* API_META_RSP_EVT */ {BTA_AV_RC_FREE_RSP, BTA_AV_INIT_ST },
122 /* API_RC_CLOSE_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
123 /* AVRC_OPEN_EVT */ {BTA_AV_RC_OPENED, BTA_AV_OPEN_ST },
124 /* AVRC_MSG_EVT */ {BTA_AV_RC_FREE_MSG, BTA_AV_INIT_ST },
125 /* AVRC_NONE_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
126 };
127
128 /* state table for open state */
129 static const UINT8 bta_av_st_open[][BTA_AV_NUM_COLS] = {
130 /* Event Action 1 Next state */
131 /* API_DISABLE_EVT */ {BTA_AV_DISABLE, BTA_AV_INIT_ST },
132 /* API_REMOTE_CMD_EVT */ {BTA_AV_RC_REMOTE_CMD, BTA_AV_OPEN_ST },
133 /* API_VENDOR_CMD_EVT */ {BTA_AV_RC_VENDOR_CMD, BTA_AV_OPEN_ST },
134 /* API_VENDOR_RSP_EVT */ {BTA_AV_RC_VENDOR_RSP, BTA_AV_OPEN_ST },
135 /* API_META_RSP_EVT */ {BTA_AV_RC_META_RSP, BTA_AV_OPEN_ST },
136 /* API_RC_CLOSE_EVT */ {BTA_AV_RC_CLOSE, BTA_AV_OPEN_ST },
137 /* AVRC_OPEN_EVT */ {BTA_AV_RC_OPENED, BTA_AV_OPEN_ST },
138 /* AVRC_MSG_EVT */ {BTA_AV_RC_MSG, BTA_AV_OPEN_ST },
139 /* AVRC_NONE_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
140 };
141
142 /* type for state table */
143 typedef const UINT8 (*tBTA_AV_ST_TBL)[BTA_AV_NUM_COLS];
144
145 /* state table */
146 static const tBTA_AV_ST_TBL bta_av_st_tbl[] = {
147 bta_av_st_init,
148 bta_av_st_open
149 };
150
151 typedef void (*tBTA_AV_NSM_ACT)(tBTA_AV_DATA *p_data);
152 static void bta_av_api_enable(tBTA_AV_DATA *p_data);
153 static void bta_av_api_register(tBTA_AV_DATA *p_data);
154 #if (BTA_AV_SINK_INCLUDED == TRUE)
155 static void bta_av_api_sink_enable(tBTA_AV_DATA *p_data);
156 static void bta_av_api_get_delay_value(tBTA_AV_DATA *p_data);
157 #endif
158 static void bta_av_ci_data(tBTA_AV_DATA *p_data);
159 #if (AVDT_REPORTING == TRUE)
160 static void bta_av_rpc_conn(tBTA_AV_DATA *p_data);
161 #endif
162 static void bta_av_api_to_ssm(tBTA_AV_DATA *p_data);
163
164 static void bta_av_sco_chg_cback(tBTA_SYS_CONN_STATUS status, UINT8 id, UINT8
165 app_id, BD_ADDR peer_addr);
166 static void bta_av_sys_rs_cback (tBTA_SYS_CONN_STATUS status, UINT8 id, UINT8 app_id, BD_ADDR peer_addr);
167
168
169 /* action functions */
170 const tBTA_AV_NSM_ACT bta_av_nsm_act[] = {
171 bta_av_api_enable, /* BTA_AV_API_ENABLE_EVT */
172 bta_av_api_register, /* BTA_AV_API_REGISTER_EVT */
173 bta_av_api_deregister, /* BTA_AV_API_DEREGISTER_EVT */
174 bta_av_api_disconnect, /* BTA_AV_API_DISCONNECT_EVT */
175 bta_av_ci_data, /* BTA_AV_CI_SRC_DATA_READY_EVT */
176 bta_av_sig_chg, /* BTA_AV_SIG_CHG_EVT */
177 bta_av_sig_timer, /* BTA_AV_SIG_TIMER_EVT */
178 bta_av_rc_disc_done, /* BTA_AV_SDP_AVRC_DISC_EVT */
179 bta_av_rc_closed, /* BTA_AV_AVRC_CLOSE_EVT */
180 bta_av_conn_chg, /* BTA_AV_CONN_CHG_EVT */
181 bta_av_dereg_comp, /* BTA_AV_DEREG_COMP_EVT */
182 #if (BTA_AV_SINK_INCLUDED == TRUE)
183 bta_av_api_sink_enable, /* BTA_AV_API_SINK_ENABLE_EVT */
184 bta_av_api_get_delay_value, /* BTA_AV_API_GET_DELAY_VALUE_EVT */
185 #endif
186 #if (AVDT_REPORTING == TRUE)
187 bta_av_rpc_conn, /* BTA_AV_AVDT_RPT_CONN_EVT */
188 #endif
189 bta_av_api_to_ssm, /* BTA_AV_API_START_EVT */
190 bta_av_api_to_ssm, /* BTA_AV_API_STOP_EVT */
191 bta_av_api_to_ssm, /* BTA_AV_API_SET_DELAY_VALUE_EVT */
192 };
193
194 /*****************************************************************************
195 ** Global data
196 *****************************************************************************/
197
198 /* AV control block */
199 #if BTA_DYNAMIC_MEMORY == FALSE
200 tBTA_AV_CB bta_av_cb;
201 #else
202 tBTA_AV_CB *bta_av_cb_ptr;
203 #endif
204
205 /*******************************************************************************
206 **
207 ** Function bta_av_timer_cback
208 **
209 ** Description forward the event to stream state machine
210 **
211 ** Returns void
212 **
213 *******************************************************************************/
bta_av_timer_cback(void * p_tle)214 static void bta_av_timer_cback(void *p_tle)
215 {
216 BT_HDR *p_buf;
217 TIMER_LIST_ENT *p = (TIMER_LIST_ENT *)p_tle;
218 int xx;
219 tBTA_AV_SCB *p_scb = NULL;
220
221 /* find the SCB that has the timer */
222 for (xx = 0; xx < BTA_AV_NUM_STRS; xx++) {
223 if (bta_av_cb.p_scb[xx] && &(bta_av_cb.p_scb[xx]->timer) == p) {
224 p_scb = bta_av_cb.p_scb[xx];
225 break;
226 }
227 }
228
229 if (p_scb && (p_buf = (BT_HDR *) osi_malloc(sizeof(BT_HDR))) != NULL) {
230 /* send the event through the audio state machine.
231 * only when the audio SM is open, the main SM opens the RC connection as INT */
232 p_buf->event = p->event;
233 p_buf->layer_specific = p_scb->hndl;
234 bta_sys_sendmsg(p_buf);
235 }
236 }
237
238 /*******************************************************************************
239 **
240 ** Function bta_av_api_enable
241 **
242 ** Description Handle an API enable event.
243 **
244 **
245 ** Returns void
246 **
247 *******************************************************************************/
bta_av_api_enable(tBTA_AV_DATA * p_data)248 static void bta_av_api_enable(tBTA_AV_DATA *p_data)
249 {
250 int i;
251 tBTA_AV_ENABLE enable;
252
253 /* initialize control block */
254 memset(&bta_av_cb, 0, sizeof(tBTA_AV_CB));
255
256 for (i = 0; i < BTA_AV_NUM_RCB; i++) {
257 bta_av_cb.rcb[i].handle = BTA_AV_RC_HANDLE_NONE;
258 }
259
260 bta_av_cb.rc_acp_handle = BTA_AV_RC_HANDLE_NONE;
261
262 /* store parameters */
263 bta_av_cb.p_cback = p_data->api_enable.p_cback;
264 bta_av_cb.features = p_data->api_enable.features;
265 bta_av_cb.sec_mask = p_data->api_enable.sec_mask;
266
267 enable.features = bta_av_cb.features;
268
269 /* Register for SCO change event */
270 if (!(bta_av_cb.features & BTA_AV_FEAT_NO_SCO_SSPD)) {
271 bta_sys_sco_register(bta_av_sco_chg_cback);
272 }
273
274 /* call callback with enable event */
275 (*bta_av_cb.p_cback)(BTA_AV_ENABLE_EVT, (tBTA_AV *)&enable);
276 }
277
278 /*******************************************************************************
279 **
280 ** Function bta_av_addr_to_scb
281 **
282 ** Description find the stream control block by the peer addr
283 **
284 ** Returns void
285 **
286 *******************************************************************************/
bta_av_addr_to_scb(BD_ADDR bd_addr)287 static tBTA_AV_SCB *bta_av_addr_to_scb(BD_ADDR bd_addr)
288 {
289 tBTA_AV_SCB *p_scb = NULL;
290 int xx;
291
292 for (xx = 0; xx < BTA_AV_NUM_STRS; xx++) {
293 if (bta_av_cb.p_scb[xx]) {
294 if (!bdcmp(bd_addr, bta_av_cb.p_scb[xx]->peer_addr)) {
295 p_scb = bta_av_cb.p_scb[xx];
296 break;
297 }
298 }
299 }
300 return p_scb;
301 }
302
303 /*******************************************************************************
304 **
305 ** Function bta_av_hndl_to_scb
306 **
307 ** Description find the stream control block by the handle
308 **
309 ** Returns void
310 **
311 *******************************************************************************/
bta_av_hndl_to_scb(UINT16 handle)312 tBTA_AV_SCB *bta_av_hndl_to_scb(UINT16 handle)
313 {
314 tBTA_AV_HNDL hndl = (tBTA_AV_HNDL)handle;
315 tBTA_AV_SCB *p_scb = NULL;
316 UINT8 idx = (hndl & BTA_AV_HNDL_MSK);
317
318 if (idx && (idx <= BTA_AV_NUM_STRS) ) {
319 p_scb = bta_av_cb.p_scb[idx - 1];
320 }
321 return p_scb;
322 }
323
324 /*******************************************************************************
325 **
326 ** Function bta_av_alloc_scb
327 **
328 ** Description allocate stream control block,
329 ** register the service to stack
330 ** create SDP record
331 **
332 ** Returns void
333 **
334 *******************************************************************************/
bta_av_alloc_scb(tBTA_AV_CHNL chnl)335 static tBTA_AV_SCB *bta_av_alloc_scb(tBTA_AV_CHNL chnl)
336 {
337 tBTA_AV_SCB *p_ret = NULL;
338 int xx;
339 tBTA_AV_STATUS sts = BTA_AV_SUCCESS;
340
341 if (chnl == BTA_AV_CHNL_VIDEO) {
342 if (p_bta_av_cfg->p_act_tbl == NULL || p_bta_av_cfg->p_reg == NULL) {
343 APPL_TRACE_ERROR("Video streaming not supported");
344 sts = BTA_AV_FAIL;
345 } else {
346 /* allow only one Video channel */
347 if (bta_av_cb.reg_video) {
348 APPL_TRACE_ERROR("Already registered");
349 sts = BTA_AV_FAIL;
350 }
351 }
352 } else if (chnl != BTA_AV_CHNL_AUDIO) {
353 APPL_TRACE_ERROR("bad channel: %d\n", chnl);
354 sts = BTA_AV_FAIL;
355 }
356
357 if (sts == BTA_AV_SUCCESS) {
358 for (xx = 0; xx < BTA_AV_NUM_STRS; xx++) {
359 if (bta_av_cb.p_scb[xx] == NULL) {
360 /* found an empty spot */
361 p_ret = (tBTA_AV_SCB *)osi_malloc(sizeof(tBTA_AV_SCB));
362 if (p_ret) {
363 memset(p_ret, 0, sizeof(tBTA_AV_SCB));
364 p_ret->rc_handle = BTA_AV_RC_HANDLE_NONE;
365 p_ret->chnl = chnl;
366 p_ret->hndl = (tBTA_AV_HNDL)((xx + 1) | chnl);
367 p_ret->hdi = xx;
368 p_ret->a2d_list = list_new(NULL);
369 bta_av_cb.p_scb[xx] = p_ret;
370 }
371 break;
372 }
373 }
374 }
375 return p_ret;
376 }
377
378 /*******************************************************************************
379 **
380 ** Function bta_av_free_scb
381 **
382 ** Description free stream control block,
383 **
384 **
385 ** Returns void
386 **
387 *******************************************************************************/
bta_av_free_scb(tBTA_AV_SCB * p_scb)388 UNUSED_ATTR static void bta_av_free_scb(tBTA_AV_SCB *p_scb)
389 {
390 // NOTE(google) This free currently is not called
391 assert(p_scb != NULL);
392
393 list_free(p_scb->a2d_list);
394 osi_free(p_scb);
395 }
396
397 /*******************************************************************************
398 *******************************************************************************/
bta_av_conn_cback(UINT8 handle,BD_ADDR bd_addr,UINT8 event,tAVDT_CTRL * p_data)399 void bta_av_conn_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data)
400 {
401 tBTA_AV_STR_MSG *p_msg;
402 UINT16 evt = 0;
403 tBTA_AV_SCB *p_scb = NULL;
404 UNUSED(handle);
405
406 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
407 if (event == BTA_AR_AVDT_CONN_EVT ||
408 event == AVDT_CONNECT_IND_EVT || event == AVDT_DISCONNECT_IND_EVT)
409 #else
410 if (event == AVDT_CONNECT_IND_EVT || event == AVDT_DISCONNECT_IND_EVT)
411 #endif
412 {
413 evt = BTA_AV_SIG_CHG_EVT;
414 if (AVDT_DISCONNECT_IND_EVT == event) {
415 p_scb = bta_av_addr_to_scb(bd_addr);
416 }
417 else if (AVDT_CONNECT_IND_EVT == event) {
418 APPL_TRACE_DEBUG("CONN_IND is ACP:%d\n", p_data->hdr.err_param);
419 }
420
421 if ((p_msg = (tBTA_AV_STR_MSG *) osi_malloc((UINT16) (sizeof(tBTA_AV_STR_MSG)))) != NULL) {
422 p_msg->hdr.event = evt;
423 p_msg->hdr.layer_specific = event;
424 p_msg->hdr.offset = p_data->hdr.err_param;
425 bdcpy(p_msg->bd_addr, bd_addr);
426 if (p_scb) {
427 APPL_TRACE_DEBUG("scb hndl x%x, role x%x\n", p_scb->hndl, p_scb->role);
428 }
429 APPL_TRACE_DEBUG("conn_cback bd_addr:%02x-%02x-%02x-%02x-%02x-%02x\n",
430 bd_addr[0], bd_addr[1],
431 bd_addr[2], bd_addr[3],
432 bd_addr[4], bd_addr[5]);
433 bta_sys_sendmsg(p_msg);
434 }
435 }
436 }
437
438 #if AVDT_REPORTING == TRUE
439 /*******************************************************************************
440 **
441 ** Function bta_av_a2dp_report_cback
442 **
443 ** Description A2DP report callback.
444 **
445 ** Returns void
446 **
447 *******************************************************************************/
bta_av_a2dp_report_cback(UINT8 handle,AVDT_REPORT_TYPE type,tAVDT_REPORT_DATA * p_data)448 static void bta_av_a2dp_report_cback(UINT8 handle, AVDT_REPORT_TYPE type,
449 tAVDT_REPORT_DATA *p_data)
450 {
451 UNUSED(handle);
452 UNUSED(type);
453 UNUSED(p_data);
454 /* Do not need to handle report data for now.
455 * This empty function is here for conformance reasons. */
456 }
457 #endif
458
459 #if (BTA_AV_SINK_INCLUDED == TRUE)
460 /*******************************************************************************
461 **
462 ** Function bta_av_api_sink_enable
463 **
464 ** Description activate, deactive A2DP Sink,
465 **
466 ** Returns void
467 **
468 *******************************************************************************/
469
bta_av_api_sink_enable(tBTA_AV_DATA * p_data)470 static void bta_av_api_sink_enable(tBTA_AV_DATA *p_data)
471 {
472 UINT16 activate_sink = 0;
473 activate_sink = p_data->hdr.layer_specific;
474 APPL_TRACE_DEBUG("bta_av_api_sink_enable %d \n", activate_sink)
475 char p_service_name[BTA_SERVICE_NAME_LEN + 1];
476 BCM_STRNCPY_S(p_service_name, BTIF_AVK_SERVICE_NAME, BTA_SERVICE_NAME_LEN);
477 p_service_name[BTA_SERVICE_NAME_LEN] = '\0';
478
479 if (activate_sink) {
480 AVDT_SINK_Activate();
481 if (bta_av_cb.sdp_a2d_snk_handle == 0) {
482 bta_av_cb.sdp_a2d_snk_handle = SDP_CreateRecord();
483 A2D_AddRecord(UUID_SERVCLASS_AUDIO_SINK, p_service_name, NULL,
484 A2D_SUPF_PLAYER, bta_av_cb.sdp_a2d_snk_handle);
485 bta_sys_add_uuid(UUID_SERVCLASS_AUDIO_SINK);
486 }
487 } else {
488 AVDT_SINK_Deactivate();
489 if (bta_av_cb.sdp_a2d_snk_handle != 0) {
490 SDP_DeleteRecord(bta_av_cb.sdp_a2d_snk_handle);
491 bta_av_cb.sdp_a2d_snk_handle = 0;
492 bta_sys_remove_uuid(UUID_SERVCLASS_AUDIO_SINK);
493 }
494 }
495 }
496
497 /*******************************************************************************
498 **
499 ** Function bta_av_api_get_delay_value
500 **
501 ** Description Get delay reporting value
502 **
503 **
504 ** Returns void
505 **
506 *******************************************************************************/
bta_av_api_get_delay_value(tBTA_AV_DATA * p_data)507 static void bta_av_api_get_delay_value(tBTA_AV_DATA *p_data)
508 {
509 UNUSED(p_data);
510 tBTA_AV_DELAY delay;
511
512 delay.delay_value = AVDT_GetDelayValue();
513
514 /* call callback with get delay value event */
515 (*bta_av_cb.p_cback)(BTA_AV_GET_DELAY_VALUE_EVT, (tBTA_AV *)&delay);
516 }
517 #endif
518 /*******************************************************************************
519 **
520 ** Function bta_av_api_register
521 **
522 ** Description allocate stream control block,
523 ** register the service to stack
524 ** create SDP record
525 **
526 ** Returns void
527 **
528 *******************************************************************************/
bta_av_api_register(tBTA_AV_DATA * p_data)529 static void bta_av_api_register(tBTA_AV_DATA *p_data)
530 {
531 tBTA_AV_REGISTER registr;
532 tBTA_AV_SCB *p_scb; /* stream control block */
533 tAVDT_REG reg;
534 tAVDT_CS cs;
535 char *p_service_name;
536 tBTA_AV_CODEC codec_type;
537 tBTA_UTL_COD cod;
538 UINT8 index = 0;
539 char p_avk_service_name[BTA_SERVICE_NAME_LEN + 1];
540 BCM_STRNCPY_S(p_avk_service_name, BTIF_AVK_SERVICE_NAME, BTA_SERVICE_NAME_LEN);
541 p_avk_service_name[BTA_SERVICE_NAME_LEN] = '\0';
542
543 memset(&cs, 0, sizeof(tAVDT_CS));
544
545 registr.status = BTA_AV_FAIL_RESOURCES;
546 registr.app_id = p_data->api_reg.app_id;
547 registr.chnl = (tBTA_AV_CHNL)p_data->hdr.layer_specific;
548 registr.p_bta_av_cos = p_data->api_reg.bta_av_cos;
549 registr.p_bta_avrc_cos = p_data->api_reg.bta_avrc_cos;
550
551 // set the avrc call-out functions
552 bta_av_cb.p_rc_cos = p_data->api_reg.bta_avrc_cos;
553
554 do {
555 p_scb = bta_av_alloc_scb(registr.chnl);
556 if (p_scb == NULL) {
557 APPL_TRACE_ERROR("failed to alloc SCB");
558 break;
559 }
560
561 registr.hndl = p_scb->hndl;
562 p_scb->app_id = registr.app_id;
563
564 /* initialize the stream control block */
565 p_scb->timer.p_cback = (TIMER_CBACK *)&bta_av_timer_cback;
566 registr.status = BTA_AV_SUCCESS;
567
568 if ((bta_av_cb.reg_audio + bta_av_cb.reg_video) == 0) {
569 /* the first channel registered. register to AVDTP */
570 reg.ctrl_mtu = p_bta_av_cfg->sig_mtu;
571 reg.ret_tout = BTA_AV_RET_TOUT;
572 reg.sig_tout = BTA_AV_SIG_TOUT;
573 reg.idle_tout = BTA_AV_IDLE_TOUT;
574 reg.sec_mask = bta_av_cb.sec_mask;
575 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
576 bta_ar_reg_avdt(®, bta_av_conn_cback, BTA_ID_AV);
577 #endif
578 bta_sys_role_chg_register(&bta_av_sys_rs_cback);
579
580 /* create remote control TG service if required */
581 if (bta_av_cb.features & (BTA_AV_FEAT_RCTG)) {
582 /* register with no authorization; let AVDTP use authorization instead */
583 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
584 bta_ar_reg_avct(p_bta_av_cfg->avrc_mtu, p_bta_av_cfg->avrc_br_mtu,
585 (UINT8)(bta_av_cb.sec_mask & (~BTA_SEC_AUTHORIZE)), BTA_ID_AV);
586 if (p_data->api_reg.tsep == AVDT_TSEP_SRC) {
587 bta_ar_reg_avrc(UUID_SERVCLASS_AV_REM_CTRL_TARGET, "AV Remote Control Target\n", NULL,
588 p_bta_av_cfg->avrc_src_tg_cat, BTA_ID_AV, p_bta_av_cfg->avrc_br);
589 } else {
590 bta_ar_reg_avrc(UUID_SERVCLASS_AV_REM_CTRL_TARGET, "AV Remote Control Target\n", NULL,
591 p_bta_av_cfg->avrc_snk_tg_cat, BTA_ID_AV, p_bta_av_cfg->avrc_br);
592 }
593 #endif
594 }
595
596 /* Set the Calss of Device (Audio & Capturing/Rendering service class bit) */
597 if (p_data->api_reg.tsep == AVDT_TSEP_SRC) {
598 cod.service = BTM_COD_SERVICE_CAPTURING | BTM_COD_SERVICE_AUDIO;
599 cod.major = BTM_COD_MAJOR_AUDIO;
600 cod.minor = BTM_COD_MINOR_UNCLASSIFIED;
601 } else {
602 #if (BTA_AV_SINK_INCLUDED == TRUE)
603 cod.service = BTM_COD_SERVICE_RENDERING | BTM_COD_SERVICE_AUDIO;
604 cod.major = BTM_COD_MAJOR_AUDIO;
605 cod.minor = BTM_COD_MINOR_LOUDSPEAKER;
606 #endif
607 }
608 utl_set_device_class(&cod, BTA_UTL_SET_COD_ALL);
609 } /* if 1st channel */
610
611 /* get stream configuration and create stream */
612 /* memset(&cs.cfg,0,sizeof(tAVDT_CFG)); */
613 cs.cfg.num_codec = 1;
614 cs.tsep = p_data->api_reg.tsep;
615
616 /*
617 * memset of cs takes care setting call back pointers to null.
618 cs.p_data_cback = NULL;
619 cs.p_report_cback = NULL;
620 */
621 cs.nsc_mask = AVDT_NSC_RECONFIG |
622 ((bta_av_cb.features & BTA_AV_FEAT_PROTECT) ? 0 : AVDT_NSC_SECURITY);
623 APPL_TRACE_DEBUG("nsc_mask: 0x%x\n", cs.nsc_mask);
624
625 if (p_data->api_reg.p_service_name[0] == 0) {
626 p_service_name = NULL;
627 } else {
628 p_service_name = p_data->api_reg.p_service_name;
629 }
630
631 p_scb->suspend_sup = TRUE;
632 p_scb->recfg_sup = TRUE;
633
634 cs.p_ctrl_cback = bta_av_dt_cback[p_scb->hdi];
635 if (registr.chnl == BTA_AV_CHNL_AUDIO) {
636 /* set up the audio stream control block */
637 p_scb->p_act_tbl = (const tBTA_AV_ACT *)bta_av_a2d_action;
638 p_scb->p_cos = registr.p_bta_av_cos;
639 p_scb->media_type = AVDT_MEDIA_AUDIO;
640 cs.cfg.psc_mask = AVDT_PSC_TRANS;
641 cs.media_type = AVDT_MEDIA_AUDIO;
642 cs.mtu = p_bta_av_cfg->audio_mtu;
643 cs.flush_to = L2CAP_DEFAULT_FLUSH_TO;
644 #if AVDT_REPORTING == TRUE
645 if (bta_av_cb.features & BTA_AV_FEAT_REPORT) {
646 cs.cfg.psc_mask |= AVDT_PSC_REPORT;
647 cs.p_report_cback = bta_av_a2dp_report_cback;
648 #if AVDT_MULTIPLEXING == TRUE
649 cs.cfg.mux_tsid_report = 2;
650 #endif
651 }
652 #endif
653 if (bta_av_cb.features & BTA_AV_FEAT_DELAY_RPT) {
654 cs.cfg.psc_mask |= AVDT_PSC_DELAY_RPT;
655 a2d_set_avdt_sdp_ver(AVDT_VERSION_SYNC);
656 a2d_set_a2dp_sdp_ver(A2D_VERSION_1_4);
657 }
658
659 /* keep the configuration in the stream control block */
660 memcpy(&p_scb->cfg, &cs.cfg, sizeof(tAVDT_CFG));
661 while (index < BTA_AV_MAX_SEPS &&
662 (p_scb->p_cos->init)(&codec_type, cs.cfg.codec_info,
663 &cs.cfg.num_protect, cs.cfg.protect_info, p_data->api_reg.tsep) == TRUE) {
664
665 #if (BTA_AV_SINK_INCLUDED == TRUE)
666 if (p_data->api_reg.tsep == AVDT_TSEP_SNK) {
667 cs.p_data_cback = bta_av_stream_data_cback;
668 }
669 APPL_TRACE_DEBUG(" SEP Type = %d\n", cs.tsep);
670 #endif
671 if (AVDT_CreateStream(&p_scb->seps[index].av_handle, &cs) == AVDT_SUCCESS) {
672 p_scb->seps[index].codec_type = codec_type;
673
674 #if (BTA_AV_SINK_INCLUDED == TRUE)
675 p_scb->seps[index].tsep = cs.tsep;
676 if (cs.tsep == AVDT_TSEP_SNK) {
677 p_scb->seps[index].p_app_data_cback = p_data->api_reg.p_app_data_cback;
678 } else {
679 p_scb->seps[index].p_app_data_cback = NULL; /* In case of A2DP SOURCE we don't need a callback to handle media packets */
680 }
681 #endif
682
683 APPL_TRACE_DEBUG("audio[%d] av_handle: %d codec_type: %d\n",
684 index, p_scb->seps[index].av_handle, p_scb->seps[index].codec_type);
685 index++;
686 } else {
687 break;
688 }
689 }
690
691 if (!bta_av_cb.reg_audio) {
692 if (p_data->api_reg.tsep == AVDT_TSEP_SRC) {
693 /* create the SDP records on the 1st audio channel */
694 bta_av_cb.sdp_a2d_handle = SDP_CreateRecord();
695 A2D_AddRecord(UUID_SERVCLASS_AUDIO_SOURCE, p_service_name, NULL,
696 A2D_SUPF_PLAYER, bta_av_cb.sdp_a2d_handle);
697 bta_sys_add_uuid(UUID_SERVCLASS_AUDIO_SOURCE);
698 } else {
699 #if (BTA_AV_SINK_INCLUDED == TRUE)
700 bta_av_cb.sdp_a2d_snk_handle = SDP_CreateRecord();
701 A2D_AddRecord(UUID_SERVCLASS_AUDIO_SINK, p_avk_service_name, NULL,
702 A2D_SUPF_PLAYER, bta_av_cb.sdp_a2d_snk_handle);
703 bta_sys_add_uuid(UUID_SERVCLASS_AUDIO_SINK);
704 #endif
705 }
706 /* start listening when A2DP is registered */
707 if (bta_av_cb.features & BTA_AV_FEAT_RCTG) {
708 bta_av_rc_create(&bta_av_cb, AVCT_ACP, 0, BTA_AV_NUM_LINKS + 1);
709 }
710
711 /* if the AV and AVK are both supported, it cannot support the CT role */
712 if (bta_av_cb.features & (BTA_AV_FEAT_RCCT)) {
713 /* if TG is not supported, we need to register to AVCT now */
714 if ((bta_av_cb.features & (BTA_AV_FEAT_RCTG)) == 0) {
715 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
716 bta_ar_reg_avct(p_bta_av_cfg->avrc_mtu, p_bta_av_cfg->avrc_br_mtu,
717 (UINT8)(bta_av_cb.sec_mask & (~BTA_SEC_AUTHORIZE)), BTA_ID_AV);
718 #endif
719 }
720 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
721 /* create an SDP record as AVRC CT. */
722 if (p_data->api_reg.tsep == AVDT_TSEP_SRC) {
723 bta_ar_reg_avrc(UUID_SERVCLASS_AV_REMOTE_CONTROL, "AV Remote Control Controller\n", NULL,
724 p_bta_av_cfg->avrc_src_ct_cat, BTA_ID_AV, p_bta_av_cfg->avrc_br);
725 } else {
726 bta_ar_reg_avrc(UUID_SERVCLASS_AV_REMOTE_CONTROL, "AV Remote Control Controller\n", NULL,
727 p_bta_av_cfg->avrc_snk_ct_cat, BTA_ID_AV, p_bta_av_cfg->avrc_br);
728 }
729 #endif
730 }
731 }
732 bta_av_cb.reg_audio |= BTA_AV_HNDL_TO_MSK(p_scb->hdi);
733 APPL_TRACE_DEBUG("reg_audio: 0x%x\n", bta_av_cb.reg_audio);
734 } else {
735 bta_av_cb.reg_video = BTA_AV_HNDL_TO_MSK(p_scb->hdi);
736 bta_av_cb.sdp_vdp_handle = SDP_CreateRecord();
737 /* register the video channel */
738 /* no need to verify the function pointer here. it's verified prior */
739 (*p_bta_av_cfg->p_reg)(&cs, p_service_name, p_scb);
740 }
741 } while (0);
742
743 /* call callback with register event */
744 (*bta_av_cb.p_cback)(BTA_AV_REGISTER_EVT, (tBTA_AV *)®istr);
745 }
746
747 /*******************************************************************************
748 **
749 ** Function bta_av_api_deregister
750 **
751 ** Description de-register a channel
752 **
753 **
754 ** Returns void
755 **
756 *******************************************************************************/
bta_av_api_deregister(tBTA_AV_DATA * p_data)757 void bta_av_api_deregister(tBTA_AV_DATA *p_data)
758 {
759 tBTA_AV_SCB *p_scb = bta_av_hndl_to_scb(p_data->hdr.layer_specific);
760
761 if (p_scb) {
762 p_scb->deregistring = TRUE;
763 bta_av_ssm_execute(p_scb, BTA_AV_API_CLOSE_EVT, p_data);
764 } else {
765 bta_av_dereg_comp(p_data);
766 }
767 }
768
769 /*******************************************************************************
770 **
771 ** Function bta_av_ci_data
772 **
773 ** Description forward the BTA_AV_CI_SRC_DATA_READY_EVT to stream state machine
774 **
775 **
776 ** Returns void
777 **
778 *******************************************************************************/
bta_av_ci_data(tBTA_AV_DATA * p_data)779 static void bta_av_ci_data(tBTA_AV_DATA *p_data)
780 {
781 tBTA_AV_SCB *p_scb;
782 int i;
783 UINT8 chnl = (UINT8)p_data->hdr.layer_specific;
784
785 for ( i = 0; i < BTA_AV_NUM_STRS; i++ ) {
786 p_scb = bta_av_cb.p_scb[i];
787
788 if (p_scb && p_scb->chnl == chnl) {
789 bta_av_ssm_execute(p_scb, BTA_AV_SRC_DATA_READY_EVT, p_data);
790 }
791 }
792 }
793
794 /*******************************************************************************
795 **
796 ** Function bta_av_rpc_conn
797 **
798 ** Description report report channel open
799 **
800 ** Returns void
801 **
802 *******************************************************************************/
803 #if (AVDT_REPORTING == TRUE)
bta_av_rpc_conn(tBTA_AV_DATA * p_data)804 static void bta_av_rpc_conn(tBTA_AV_DATA *p_data)
805 {
806 UNUSED(p_data);
807 }
808 #endif
809
810 /*******************************************************************************
811 **
812 ** Function bta_av_api_to_ssm
813 **
814 ** Description forward the API request to stream state machine
815 **
816 **
817 ** Returns void
818 **
819 *******************************************************************************/
bta_av_api_to_ssm(tBTA_AV_DATA * p_data)820 static void bta_av_api_to_ssm(tBTA_AV_DATA *p_data)
821 {
822 int xx;
823 UINT16 event = p_data->hdr.event - BTA_AV_FIRST_A2S_API_EVT + BTA_AV_FIRST_A2S_SSM_EVT;
824
825 for (xx = 0; xx < BTA_AV_NUM_STRS; xx++) {
826 bta_av_ssm_execute(bta_av_cb.p_scb[xx], event, p_data);
827 }
828 }
829
830 /*******************************************************************************
831 **
832 ** Function bta_av_chk_start
833 **
834 ** Description if this is audio channel, check if more than one audio
835 ** channel is connected & already started.
836 **
837 ** Returns TRUE, if need api_start
838 **
839 *******************************************************************************/
bta_av_chk_start(tBTA_AV_SCB * p_scb)840 BOOLEAN bta_av_chk_start(tBTA_AV_SCB *p_scb)
841 {
842 BOOLEAN start = FALSE;
843 tBTA_AV_SCB *p_scbi;
844 int i;
845
846 if (p_scb->chnl == BTA_AV_CHNL_AUDIO) {
847 if ((bta_av_cb.audio_open_cnt >= 2) &&
848 ((0 == (p_scb->role & BTA_AV_ROLE_AD_ACP)) || /* Outgoing connection or */
849 (bta_av_cb.features & BTA_AV_FEAT_ACP_START))) { /* auto-starting option */
850 /* more than one audio channel is connected */
851 /* if this is the 2nd stream as ACP, give INT a chance to issue the START command */
852 for (i = 0; i < BTA_AV_NUM_STRS; i++) {
853 p_scbi = bta_av_cb.p_scb[i];
854 if (p_scbi && p_scbi->chnl == BTA_AV_CHNL_AUDIO && p_scbi->co_started) {
855 start = TRUE;
856 /* may need to update the flush timeout of this already started stream */
857 if (p_scbi->co_started != bta_av_cb.audio_open_cnt) {
858 p_scbi->co_started = bta_av_cb.audio_open_cnt;
859 L2CA_SetFlushTimeout(p_scbi->peer_addr, p_bta_av_cfg->p_audio_flush_to[p_scbi->co_started - 1] );
860 }
861 }
862 }
863 }
864 }
865 return start;
866 }
867
868 /*******************************************************************************
869 **
870 ** Function bta_av_restore_switch
871 **
872 ** Description assume that the caller of this function already makes
873 ** sure that there's only one ACL connection left
874 **
875 ** Returns void
876 **
877 *******************************************************************************/
bta_av_restore_switch(void)878 void bta_av_restore_switch (void)
879 {
880 tBTA_AV_CB *p_cb = &bta_av_cb;
881 int i;
882 UINT8 mask;
883
884 APPL_TRACE_DEBUG("reg_audio: 0x%x\n", bta_av_cb.reg_audio);
885 for (i = 0; i < BTA_AV_NUM_STRS; i++) {
886 mask = BTA_AV_HNDL_TO_MSK(i);
887 if (p_cb->conn_audio == mask) {
888 if (p_cb->p_scb[i]) {
889 bta_sys_set_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH, p_cb->p_scb[i]->peer_addr);
890 }
891 break;
892 }
893 }
894 }
895
896 /*******************************************************************************
897 **
898 ** Function bta_av_sys_rs_cback
899 **
900 ** Description Receives the role change event from dm
901 **
902 ** Returns (BTA_SYS_ROLE_CHANGE, new_role, hci_status, p_bda)
903 **
904 *******************************************************************************/
bta_av_sys_rs_cback(tBTA_SYS_CONN_STATUS status,UINT8 id,UINT8 app_id,BD_ADDR peer_addr)905 static void bta_av_sys_rs_cback (tBTA_SYS_CONN_STATUS status, UINT8 id, UINT8 app_id, BD_ADDR peer_addr)
906 {
907 int i;
908 tBTA_AV_SCB *p_scb = NULL;
909 tBTA_AV_ROLE_RES *p_buf;
910 UINT8 cur_role;
911 UINT8 peer_idx = 0;
912 UNUSED(status);
913
914 APPL_TRACE_DEBUG("bta_av_sys_rs_cback: %d\n", bta_av_cb.rs_idx);
915 for (i = 0; i < BTA_AV_NUM_STRS; i++) {
916 /* loop through all the SCBs to find matching peer addresses and report the role change event */
917 /* note that more than one SCB (a2dp & vdp) maybe waiting for this event */
918 p_scb = bta_av_cb.p_scb[i];
919 if (p_scb && (bdcmp (peer_addr, p_scb->peer_addr) == 0) &&
920 (p_buf = (tBTA_AV_ROLE_RES *) osi_malloc(sizeof(tBTA_AV_ROLE_RES))) != NULL) {
921 APPL_TRACE_DEBUG("new_role:%d, hci_status:x%x hndl: x%x\n", id, app_id, p_scb->hndl);
922 /*
923 if ((id != BTM_ROLE_MASTER) && (app_id != HCI_SUCCESS))
924 {
925 bta_sys_set_policy(BTA_ID_AV, (HCI_ENABLE_MASTER_SLAVE_SWITCH|HCI_ENABLE_SNIFF_MODE), p_scb->peer_addr);
926 }
927 */
928 p_buf->hdr.event = BTA_AV_ROLE_CHANGE_EVT;
929 p_buf->hdr.layer_specific = p_scb->hndl;
930 p_buf->new_role = id;
931 p_buf->hci_status = app_id;
932 bta_sys_sendmsg(p_buf);
933
934 peer_idx = p_scb->hdi + 1; /* Handle index for the peer_addr */
935 }
936 }
937
938 /* restore role switch policy, if role switch failed */
939 if ((HCI_SUCCESS != app_id) &&
940 (BTM_GetRole (peer_addr, &cur_role) == BTM_SUCCESS) &&
941 (cur_role == BTM_ROLE_SLAVE) ) {
942 bta_sys_set_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH, peer_addr);
943 }
944
945 /* if BTA_AvOpen() was called for other device, which caused the role switch of the peer_addr, */
946 /* we need to continue opening process for the BTA_AvOpen(). */
947 if ((bta_av_cb.rs_idx != 0) && (bta_av_cb.rs_idx != peer_idx)) {
948 if ((bta_av_cb.rs_idx - 1) < BTA_AV_NUM_STRS) {
949 p_scb = bta_av_cb.p_scb[bta_av_cb.rs_idx - 1];
950 }
951 if (p_scb && p_scb->q_tag == BTA_AV_Q_TAG_OPEN) {
952 APPL_TRACE_DEBUG ("bta_av_sys_rs_cback: rs_idx(%d), hndl:x%x q_tag: %d\n",
953 bta_av_cb.rs_idx, p_scb->hndl, p_scb->q_tag);
954
955 if (HCI_SUCCESS == app_id || HCI_ERR_NO_CONNECTION == app_id) {
956 p_scb->q_info.open.switch_res = BTA_AV_RS_OK;
957 } else {
958 p_scb->q_info.open.switch_res = BTA_AV_RS_FAIL;
959 }
960
961 /* Continue av open process */
962 bta_av_do_disc_a2d (p_scb, (tBTA_AV_DATA *) & (p_scb->q_info.open));
963 }
964
965 bta_av_cb.rs_idx = 0;
966 }
967 }
968
969 /*******************************************************************************
970 **
971 ** Function bta_av_sco_chg_cback
972 **
973 ** Description receive & process the SCO connection up/down event from sys.
974 ** call setup also triggers this callback, to suspend av before sco
975 ** activity happens, or to resume av once call ends.
976 **
977 ** Returns void
978 **
979 *******************************************************************************/
bta_av_sco_chg_cback(tBTA_SYS_CONN_STATUS status,UINT8 id,UINT8 app_id,BD_ADDR peer_addr)980 static void bta_av_sco_chg_cback(tBTA_SYS_CONN_STATUS status, UINT8 id, UINT8
981 app_id, BD_ADDR peer_addr)
982 {
983 tBTA_AV_SCB *p_scb;
984 int i;
985 tBTA_AV_API_STOP stop;
986 UNUSED(app_id);
987 UNUSED(peer_addr);
988
989 APPL_TRACE_DEBUG("bta_av_sco_chg_cback:%d status:%d\n", id, status);
990 if (id) {
991 bta_av_cb.sco_occupied = TRUE;
992
993 /* either BTA_SYS_SCO_OPEN or BTA_SYS_SCO_CLOSE with remaining active SCO */
994 for (i = 0; i < BTA_AV_NUM_STRS; i++) {
995 p_scb = bta_av_cb.p_scb[i];
996
997 if ( p_scb && p_scb->co_started && (p_scb->sco_suspend == FALSE)) {
998 APPL_TRACE_DEBUG("suspending scb:%d\n", i);
999 /* scb is used and started, not suspended automatically */
1000 p_scb->sco_suspend = TRUE;
1001 stop.flush = FALSE;
1002 stop.suspend = TRUE;
1003 bta_av_ssm_execute(p_scb, BTA_AV_AP_STOP_EVT, (tBTA_AV_DATA *)&stop);
1004 }
1005 }
1006 } else {
1007 bta_av_cb.sco_occupied = FALSE;
1008
1009 for (i = 0; i < BTA_AV_NUM_STRS; i++) {
1010 p_scb = bta_av_cb.p_scb[i];
1011
1012 if ( p_scb && p_scb->sco_suspend ) { /* scb is used and suspended for SCO */
1013 APPL_TRACE_DEBUG("starting scb:%d\n", i);
1014 bta_av_ssm_execute(p_scb, BTA_AV_AP_START_EVT, NULL);
1015 }
1016 }
1017 }
1018 }
1019
1020 /*******************************************************************************
1021 **
1022 ** Function bta_av_switch_if_needed
1023 **
1024 ** Description This function checks if there is another existing AV
1025 ** channel that is local as slave role.
1026 ** If so, role switch and remove it from link policy.
1027 **
1028 ** Returns TRUE, if role switch is done
1029 **
1030 *******************************************************************************/
bta_av_switch_if_needed(tBTA_AV_SCB * p_scb)1031 BOOLEAN bta_av_switch_if_needed(tBTA_AV_SCB *p_scb)
1032 {
1033 UINT8 role;
1034 BOOLEAN needed = FALSE;
1035 tBTA_AV_SCB *p_scbi;
1036 int i;
1037 UINT8 mask;
1038
1039 for (i = 0; i < BTA_AV_NUM_STRS; i++) {
1040 mask = BTA_AV_HNDL_TO_MSK(i);
1041 p_scbi = bta_av_cb.p_scb[i];
1042 if ( p_scbi && (p_scb->hdi != i) && /* not the original channel */
1043 ((bta_av_cb.conn_audio & mask) ||/* connected audio */
1044 (bta_av_cb.conn_video & mask)) ) { /* connected video */
1045 BTM_GetRole(p_scbi->peer_addr, &role);
1046 /* this channel is open - clear the role switch link policy for this link */
1047 if (BTM_ROLE_MASTER != role) {
1048 if (bta_av_cb.features & BTA_AV_FEAT_MASTER) {
1049 bta_sys_clear_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH, p_scbi->peer_addr);
1050 }
1051 if (BTM_CMD_STARTED != BTM_SwitchRole(p_scbi->peer_addr, BTM_ROLE_MASTER, NULL)) {
1052 /* can not switch role on SCBI
1053 * start the timer on SCB - because this function is ONLY called when SCB gets API_OPEN */
1054 bta_sys_start_timer(&p_scb->timer, BTA_AV_AVRC_TIMER_EVT, BTA_AV_RS_TIME_VAL);
1055 }
1056 needed = TRUE;
1057 /* mark the original channel as waiting for RS result */
1058 bta_av_cb.rs_idx = p_scb->hdi + 1;
1059 break;
1060 }
1061 }
1062 }
1063 return needed;
1064 }
1065
1066 /*******************************************************************************
1067 **
1068 ** Function bta_av_link_role_ok
1069 **
1070 ** Description This function checks if the SCB has existing ACL connection
1071 ** If so, check if the link role fits the requirements.
1072 **
1073 ** Returns TRUE, if role is ok
1074 **
1075 *******************************************************************************/
bta_av_link_role_ok(tBTA_AV_SCB * p_scb,UINT8 bits)1076 BOOLEAN bta_av_link_role_ok(tBTA_AV_SCB *p_scb, UINT8 bits)
1077 {
1078 UINT8 role;
1079 BOOLEAN is_ok = TRUE;
1080
1081 if (BTM_GetRole(p_scb->peer_addr, &role) == BTM_SUCCESS) {
1082 LOG_INFO("%s hndl:x%x role:%d conn_audio:x%x bits:%d features:x%x\n",
1083 __func__, p_scb->hndl, role, bta_av_cb.conn_audio, bits,
1084 bta_av_cb.features);
1085 if (BTM_ROLE_MASTER != role && (A2D_BitsSet(bta_av_cb.conn_audio) > bits || (bta_av_cb.features & BTA_AV_FEAT_MASTER))) {
1086 if (bta_av_cb.features & BTA_AV_FEAT_MASTER) {
1087 bta_sys_clear_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH, p_scb->peer_addr);
1088 }
1089
1090 if (BTM_CMD_STARTED != BTM_SwitchRole(p_scb->peer_addr, BTM_ROLE_MASTER, NULL)) {
1091 /* can not switch role on SCB - start the timer on SCB */
1092 }
1093 is_ok = FALSE;
1094 p_scb->wait |= BTA_AV_WAIT_ROLE_SW_RES_START;
1095
1096 }
1097 }
1098
1099 return is_ok;
1100 }
1101
1102 /*******************************************************************************
1103 **
1104 ** Function bta_av_chk_mtu
1105 **
1106 ** Description if this is audio channel, check if more than one audio
1107 ** channel is connected.
1108 **
1109 ** Returns The smallest mtu of the connected audio channels
1110 **
1111 *******************************************************************************/
bta_av_chk_mtu(tBTA_AV_SCB * p_scb,UINT16 mtu)1112 UINT16 bta_av_chk_mtu(tBTA_AV_SCB *p_scb, UINT16 mtu)
1113 {
1114 UINT16 ret_mtu = BTA_AV_MAX_A2DP_MTU;
1115 tBTA_AV_SCB *p_scbi;
1116 int i;
1117 UINT8 mask;
1118 UNUSED(mtu);
1119
1120 /* TODO_MV mess with the mtu according to the number of EDR/non-EDR headsets */
1121 if (p_scb->chnl == BTA_AV_CHNL_AUDIO) {
1122 if (bta_av_cb.audio_open_cnt >= 2) {
1123 /* more than one audio channel is connected */
1124 for (i = 0; i < BTA_AV_NUM_STRS; i++) {
1125 p_scbi = bta_av_cb.p_scb[i];
1126 if ((p_scb != p_scbi) && p_scbi && (p_scbi->chnl == BTA_AV_CHNL_AUDIO) ) {
1127 mask = BTA_AV_HNDL_TO_MSK(i);
1128 APPL_TRACE_DEBUG("[%d] mtu: %d, mask:0x%x\n",
1129 i, p_scbi->stream_mtu, mask);
1130 if (bta_av_cb.conn_audio & mask) {
1131 if (ret_mtu > p_scbi->stream_mtu) {
1132 ret_mtu = p_scbi->stream_mtu;
1133 }
1134 }
1135 }
1136 }
1137 }
1138 APPL_TRACE_DEBUG("bta_av_chk_mtu audio count:%d, conn_audio:0x%x, ret:%d\n",
1139 bta_av_cb.audio_open_cnt, bta_av_cb.conn_audio, ret_mtu);
1140 }
1141 return ret_mtu;
1142 }
1143
1144 /*******************************************************************************
1145 **
1146 ** Function bta_av_dup_audio_buf
1147 **
1148 ** Description dup the audio data to the q_info.a2d of other audio channels
1149 **
1150 ** Returns void
1151 **
1152 *******************************************************************************/
bta_av_dup_audio_buf(tBTA_AV_SCB * p_scb,BT_HDR * p_buf)1153 void bta_av_dup_audio_buf(tBTA_AV_SCB *p_scb, BT_HDR *p_buf)
1154 {
1155 tBTA_AV_SCB *p_scbi;
1156 int i;
1157 UINT16 copy_size;
1158 BT_HDR *p_new;
1159
1160 if (!p_buf) {
1161 return;
1162 }
1163
1164 if (bta_av_cb.audio_open_cnt >= 2) {
1165 copy_size = BT_HDR_SIZE + p_buf->len + p_buf->offset;
1166 /* more than one audio channel is connected */
1167 for (i = 0; i < BTA_AV_NUM_STRS; i++) {
1168 p_scbi = bta_av_cb.p_scb[i];
1169 if ( (p_scb->hdi != i) && /* not the original channel */
1170 (bta_av_cb.conn_audio & BTA_AV_HNDL_TO_MSK(i)) && /* connected audio */
1171 p_scbi && p_scbi->co_started ) { /* scb is used and started */
1172 /* enqueue the data only when the stream is started */
1173 p_new = (BT_HDR *)osi_malloc(copy_size);
1174 if (p_new) {
1175 memcpy(p_new, p_buf, copy_size);
1176 list_append(p_scbi->a2d_list, p_new);
1177 if (list_length(p_scbi->a2d_list) > p_bta_av_cfg->audio_mqs) {
1178 // Drop the oldest packet
1179 bta_av_co_audio_drop(p_scbi->hndl);
1180 BT_HDR *p_buf = list_front(p_scbi->a2d_list);
1181 list_remove(p_scbi->a2d_list, p_buf);
1182 osi_free(p_buf);
1183 }
1184 }
1185 }
1186 }
1187 }
1188
1189 }
1190
1191 /*******************************************************************************
1192 **
1193 ** Function bta_av_sm_execute
1194 **
1195 ** Description State machine event handling function for AV
1196 **
1197 **
1198 ** Returns void
1199 **
1200 *******************************************************************************/
bta_av_sm_execute(tBTA_AV_CB * p_cb,UINT16 event,tBTA_AV_DATA * p_data)1201 void bta_av_sm_execute(tBTA_AV_CB *p_cb, UINT16 event, tBTA_AV_DATA *p_data)
1202 {
1203 tBTA_AV_ST_TBL state_table;
1204 UINT8 action;
1205
1206 APPL_TRACE_EVENT("AV event=0x%x state=%d\n", event, p_cb->state);
1207
1208 /* look up the state table for the current state */
1209 state_table = bta_av_st_tbl[p_cb->state];
1210
1211 event &= 0x00FF;
1212
1213 /* set next state */
1214 p_cb->state = state_table[event][BTA_AV_NEXT_STATE];
1215 APPL_TRACE_EVENT("next state=%d\n", p_cb->state);
1216
1217 /* execute action functions */
1218 if ((action = state_table[event][BTA_AV_ACTION_COL]) != BTA_AV_IGNORE) {
1219 (*bta_av_action[action])(p_cb, p_data);
1220 }
1221 }
1222
1223
1224 /*******************************************************************************
1225 **
1226 ** Function bta_av_hdl_event
1227 **
1228 ** Description Advanced audio/video main event handling function.
1229 **
1230 **
1231 ** Returns BOOLEAN
1232 **
1233 *******************************************************************************/
bta_av_hdl_event(BT_HDR * p_msg)1234 BOOLEAN bta_av_hdl_event(BT_HDR *p_msg)
1235 {
1236 UINT16 event = p_msg->event;
1237 UINT16 first_event = BTA_AV_FIRST_NSM_EVT;
1238
1239 if (event > BTA_AV_LAST_EVT) {
1240 return TRUE; /* to free p_msg */
1241 }
1242
1243 if (event >= first_event) {
1244 APPL_TRACE_VERBOSE("AV nsm event=0x%x(%s)\n", event, bta_av_evt_code(event));
1245 /* non state machine events */
1246 (*bta_av_nsm_act[event - BTA_AV_FIRST_NSM_EVT]) ((tBTA_AV_DATA *) p_msg);
1247 } else if (event >= BTA_AV_FIRST_SM_EVT && event <= BTA_AV_LAST_SM_EVT) {
1248 APPL_TRACE_VERBOSE("AV sm event=0x%x(%s)\n", event, bta_av_evt_code(event));
1249 /* state machine events */
1250 bta_av_sm_execute(&bta_av_cb, p_msg->event, (tBTA_AV_DATA *) p_msg);
1251 } else {
1252 APPL_TRACE_VERBOSE("handle=0x%x\n", p_msg->layer_specific);
1253 tBTA_AV_SCB *p_scb = bta_av_hndl_to_scb(p_msg->layer_specific);
1254 if (p_scb) {
1255 p_scb->disc_rsn = p_msg->offset;
1256 /* stream state machine events */
1257 bta_av_ssm_execute(p_scb, p_msg->event, (tBTA_AV_DATA *) p_msg);
1258 }
1259 }
1260 return TRUE;
1261 }
1262
1263
1264 /*****************************************************************************
1265 ** Debug Functions
1266 *****************************************************************************/
1267 /*******************************************************************************
1268 **
1269 ** Function bta_av_evt_code
1270 **
1271 ** Description
1272 **
1273 ** Returns char *
1274 **
1275 *******************************************************************************/
bta_av_evt_code(UINT16 evt_code)1276 char *bta_av_evt_code(UINT16 evt_code)
1277 {
1278 switch (evt_code) {
1279 case BTA_AV_API_DISABLE_EVT: return "API_DISABLE";
1280 case BTA_AV_API_REMOTE_CMD_EVT: return "API_REMOTE_CMD";
1281 case BTA_AV_API_VENDOR_CMD_EVT: return "API_VENDOR_CMD";
1282 case BTA_AV_API_VENDOR_RSP_EVT: return "API_VENDOR_RSP";
1283 case BTA_AV_API_META_RSP_EVT: return "API_META_RSP_EVT";
1284 case BTA_AV_API_RC_CLOSE_EVT: return "API_RC_CLOSE";
1285 case BTA_AV_AVRC_OPEN_EVT: return "AVRC_OPEN";
1286 case BTA_AV_AVRC_MSG_EVT: return "AVRC_MSG";
1287 case BTA_AV_AVRC_NONE_EVT: return "AVRC_NONE";
1288
1289 case BTA_AV_API_OPEN_EVT: return "API_OPEN";
1290 case BTA_AV_API_CLOSE_EVT: return "API_CLOSE";
1291 case BTA_AV_AP_START_EVT: return "AP_START";
1292 case BTA_AV_AP_STOP_EVT: return "AP_STOP";
1293 case BTA_AV_AP_SET_DELAY_VALUE_EVT: return "AP_SET_DELAY_VALUE";
1294 case BTA_AV_API_RECONFIG_EVT: return "API_RECONFIG";
1295 case BTA_AV_API_PROTECT_REQ_EVT: return "API_PROTECT_REQ";
1296 case BTA_AV_API_PROTECT_RSP_EVT: return "API_PROTECT_RSP";
1297 case BTA_AV_API_RC_OPEN_EVT: return "API_RC_OPEN";
1298 case BTA_AV_SRC_DATA_READY_EVT: return "SRC_DATA_READY";
1299 case BTA_AV_CI_SETCONFIG_OK_EVT: return "CI_SETCONFIG_OK";
1300 case BTA_AV_CI_SETCONFIG_FAIL_EVT: return "CI_SETCONFIG_FAIL";
1301 case BTA_AV_SDP_DISC_OK_EVT: return "SDP_DISC_OK";
1302 case BTA_AV_SDP_DISC_FAIL_EVT: return "SDP_DISC_FAIL";
1303 case BTA_AV_STR_DISC_OK_EVT: return "STR_DISC_OK";
1304 case BTA_AV_STR_DISC_FAIL_EVT: return "STR_DISC_FAIL";
1305 case BTA_AV_STR_GETCAP_OK_EVT: return "STR_GETCAP_OK";
1306 case BTA_AV_STR_GETCAP_FAIL_EVT: return "STR_GETCAP_FAIL";
1307 case BTA_AV_STR_OPEN_OK_EVT: return "STR_OPEN_OK";
1308 case BTA_AV_STR_OPEN_FAIL_EVT: return "STR_OPEN_FAIL";
1309 case BTA_AV_STR_START_OK_EVT: return "STR_START_OK";
1310 case BTA_AV_STR_START_FAIL_EVT: return "STR_START_FAIL";
1311 case BTA_AV_STR_CLOSE_EVT: return "STR_CLOSE";
1312 case BTA_AV_STR_CONFIG_IND_EVT: return "STR_CONFIG_IND";
1313 case BTA_AV_STR_SECURITY_IND_EVT: return "STR_SECURITY_IND";
1314 case BTA_AV_STR_SECURITY_CFM_EVT: return "STR_SECURITY_CFM";
1315 case BTA_AV_STR_WRITE_CFM_EVT: return "STR_WRITE_CFM";
1316 case BTA_AV_STR_SUSPEND_CFM_EVT: return "STR_SUSPEND_CFM";
1317 case BTA_AV_STR_RECONFIG_CFM_EVT: return "STR_RECONFIG_CFM";
1318 case BTA_AV_AVRC_TIMER_EVT: return "AVRC_TIMER";
1319 case BTA_AV_AVDT_CONNECT_EVT: return "AVDT_CONNECT";
1320 case BTA_AV_AVDT_DISCONNECT_EVT: return "AVDT_DISCONNECT";
1321 case BTA_AV_ROLE_CHANGE_EVT: return "ROLE_CHANGE";
1322 case BTA_AV_AVDT_DELAY_RPT_EVT: return "AVDT_DELAY_RPT";
1323 case BTA_AV_ACP_CONNECT_EVT: return "ACP_CONNECT";
1324
1325 case BTA_AV_API_ENABLE_EVT: return "API_ENABLE";
1326 case BTA_AV_API_REGISTER_EVT: return "API_REG";
1327 case BTA_AV_API_DEREGISTER_EVT: return "API_DEREG";
1328 case BTA_AV_API_DISCONNECT_EVT: return "API_DISCNT";
1329 case BTA_AV_CI_SRC_DATA_READY_EVT: return "CI_DATA_READY";
1330 case BTA_AV_SIG_CHG_EVT: return "SIG_CHG";
1331 case BTA_AV_SIG_TIMER_EVT: return "SIG_TMR";
1332 case BTA_AV_SDP_AVRC_DISC_EVT: return "SDP_AVRC_DISC";
1333 case BTA_AV_AVRC_CLOSE_EVT: return "AVRC_CLOSE";
1334 case BTA_AV_CONN_CHG_EVT: return "CONN_CHG";
1335 case BTA_AV_DEREG_COMP_EVT: return "DEREG_COMP";
1336 #if (BTA_AV_SINK_INCLUDED == TRUE)
1337 case BTA_AV_API_SINK_ENABLE_EVT: return "SINK_ENABLE";
1338 case BTA_AV_API_GET_DELAY_VALUE_EVT: return "GET_DELAY_VALUE";
1339 #endif
1340 #if (AVDT_REPORTING == TRUE)
1341 case BTA_AV_AVDT_RPT_CONN_EVT: return "RPT_CONN";
1342 #endif
1343 case BTA_AV_API_START_EVT: return "API_START";
1344 case BTA_AV_API_STOP_EVT: return "API_STOP";
1345 case BTA_AV_API_SET_DELAY_VALUE_EVT: return "API_SET_DELAY_VALUE";
1346 default: return "unknown";
1347 }
1348 }
1349
1350 /*******************************************************************************
1351 **
1352 ** Function bta_av_action_code
1353 **
1354 ** Description
1355 **
1356 ** Returns char *
1357 **
1358 *******************************************************************************/
bta_av_action_code(UINT16 action_code)1359 char *bta_av_action_code(UINT16 action_code)
1360 {
1361 switch (action_code) {
1362 case 0: return "BTA_AV_DO_DISC";
1363 case 1: return "BTA_AV_CLEANUP";
1364 case 2: return "BTA_AV_FREE_SDB";
1365 case 3: return "BTA_AV_CONFIG_IND";
1366 case 4: return "BTA_AV_DISCONNECT_REQ";
1367 case 5: return "BTA_AV_SECURITY_REQ";
1368 case 6: return "BTA_AV_SECURITY_RSP";
1369 case 7: return "BTA_AV_SETCONFIG_RSP";
1370 case 8: return "BTA_AV_ST_RC_TIMER";
1371 case 9: return "BTA_AV_STR_OPENED";
1372 case 10: return "BTA_AV_SECURITY_IND";
1373 case 11: return "BTA_AV_SECURITY_CFM";
1374 case 12: return "BTA_AV_DO_CLOSE";
1375 case 13: return "BTA_AV_CONNECT_REQ";
1376 case 14: return "BTA_AV_SDP_FAILED";
1377 case 15: return "BTA_AV_DISC_RESULTS";
1378 case 16: return "BTA_AV_DISC_RES_AS_ACP";
1379 case 17: return "BTA_AV_OPEN_FAILED";
1380 case 18: return "BTA_AV_GETCAP_RESULTS";
1381 case 19: return "BTA_AV_SETCONFIG_REJ";
1382 case 20: return "BTA_AV_DISCOVER_REQ";
1383 case 21: return "BTA_AV_CONN_FAILED";
1384 case 22: return "BTA_AV_DO_START";
1385 case 23: return "BTA_AV_STR_STOPPED";
1386 case 24: return "BTA_AV_RECONFIG";
1387 case 25: return "BTA_AV_DATA_PATH";
1388 case 26: return "BTA_AV_START_OK";
1389 case 27: return "BTA_AV_START_FAILED";
1390 case 28: return "BTA_AV_STR_CLOSED";
1391 case 29: return "BTA_AV_CLR_CONG";
1392 case 30: return "BTA_AV_SUSPEND_CFM";
1393 case 31: return "BTA_AV_RCFG_STR_OK";
1394 case 32: return "BTA_AV_RCFG_FAILED";
1395 case 33: return "BTA_AV_RCFG_CONNECT";
1396 case 34: return "BTA_AV_RCFG_DISCNTD";
1397 case 35: return "BTA_AV_SUSPEND_CONT";
1398 case 36: return "BTA_AV_RCFG_CFM";
1399 case 37: return "BTA_AV_RCFG_OPEN";
1400 case 38: return "BTA_AV_SECURITY_REJ";
1401 case 39: return "BTA_AV_OPEN_RC";
1402 case 40: return "BTA_AV_CHK_2ND_START";
1403 case 41: return "BTA_AV_SAVE_CAPS";
1404 case 42: return "BTA_AV_SET_USE_RC";
1405 case 43: return "BTA_AV_CCO_CLOSE";
1406 case 44: return "BTA_AV_SWITCH_ROLE";
1407 case 45: return "BTA_AV_ROLE_RES";
1408 case 46: return "BTA_AV_DELAY_CO";
1409 case 47: return "BTA_AV_OPEN_AT_INC";
1410 case 48: return "BTA_AV_OPEN_FAIL_SDP";
1411 case 49: return "NULL";
1412 default: return "unknown";
1413 }
1414 }
1415
1416 #endif /* BTA_AV_INCLUDED */
1417
