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