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