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