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 file contains action functions for the audio gateway.
22 *
23 ******************************************************************************/
24 #include <string.h>
25 #include "bta_ag_int.h"
26 #include "bta/bta_sys.h"
27 #include "bta/bta_ag_api.h"
28 #include "bta/bta_ag_co.h"
29 #include "stack/port_api.h"
30 #include "stack/l2c_api.h"
31 #include "bta_dm_int.h"
32 #include "bta/bta_sdp_api.h"
33 #include "bta/utl.h"
34 #include "common/bt_trace.h"
35 #include "osi/allocator.h"
36
37 #if (BTA_AG_INCLUDED == TRUE)
38 /*****************************************************************************
39 ** Constants
40 *****************************************************************************/
41
42 /* maximum length of data to read from RFCOMM */
43 #define BTA_AG_RFC_READ_MAX 512
44
45 /* maximum AT command length */
46 #define BTA_AG_CMD_MAX 512
47
48 const UINT16 bta_ag_uuid[BTA_AG_NUM_IDX] =
49 {
50 UUID_SERVCLASS_HEADSET_AUDIO_GATEWAY,
51 UUID_SERVCLASS_AG_HANDSFREE
52 };
53
54 const UINT8 bta_ag_sec_id[BTA_AG_NUM_IDX] =
55 {
56 BTM_SEC_SERVICE_HEADSET_AG,
57 BTM_SEC_SERVICE_AG_HANDSFREE
58 };
59
60 const tBTA_SERVICE_ID bta_ag_svc_id[BTA_AG_NUM_IDX] =
61 {
62 BTA_HSP_SERVICE_ID,
63 BTA_HFP_SERVICE_ID
64 };
65
66 const tBTA_SERVICE_MASK bta_ag_svc_mask[BTA_AG_NUM_IDX] =
67 {
68 BTA_HSP_SERVICE_MASK,
69 BTA_HFP_SERVICE_MASK
70 };
71
72 typedef void (*tBTA_AG_ATCMD_CBACK)(tBTA_AG_SCB *p_scb, UINT16 cmd, UINT8 arg_type,
73 char *p_arg, INT16 int_arg);
74
75 const tBTA_AG_ATCMD_CBACK bta_ag_at_cback_tbl[BTA_AG_NUM_IDX] =
76 {
77 bta_ag_at_hsp_cback,
78 bta_ag_at_hfp_cback
79 };
80
81 /*******************************************************************************
82 **
83 ** Function bta_ag_cback_open
84 **
85 ** Description Send open callback event to application.
86 **
87 **
88 ** Returns void
89 **
90 *******************************************************************************/
bta_ag_cback_open(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data,tBTA_AG_STATUS status)91 static void bta_ag_cback_open(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data, tBTA_AG_STATUS status)
92 {
93 tBTA_AG_OPEN open;
94 /* call app callback with open event */
95 open.hdr.handle = bta_ag_scb_to_idx(p_scb);
96 open.hdr.app_id = p_scb->app_id;
97 open.hdr.status = status;
98 open.service_id = bta_ag_svc_id[p_scb->conn_service];
99 if (p_data) {
100 /* if p_data is provided then we need to pick the bd address from the open api structure */
101 bdcpy(open.bd_addr, p_data->api_open.bd_addr);
102 } else {
103 bdcpy(open.bd_addr, p_scb->peer_addr);
104 }
105 (*bta_ag_cb.p_cback)(BTA_AG_OPEN_EVT, (tBTA_AG *) &open);
106 }
107
108 /*******************************************************************************
109 **
110 ** Function bta_ag_register
111 **
112 ** Description This function initializes values of the AG cb and sets up
113 ** the SDP record for the services.
114 **
115 **
116 ** Returns void
117 **
118 *******************************************************************************/
bta_ag_register(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)119 void bta_ag_register(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
120 {
121 tBTA_AG_REGISTER reg;
122 /* initialize control block */
123 p_scb->reg_services = p_data->api_register.services;
124 p_scb->serv_sec_mask = p_data->api_register.sec_mask;
125 p_scb->features = p_data->api_register.features;
126 p_scb->app_id = p_data->api_register.app_id;
127 /* create SDP records */
128 bta_ag_create_records(p_scb, p_data);
129 /* start RFCOMM servers */
130 bta_ag_start_servers(p_scb, p_scb->reg_services);
131 /* call app callback with register event */
132 reg.hdr.handle = bta_ag_scb_to_idx(p_scb);
133 reg.hdr.app_id = p_scb->app_id;
134 reg.hdr.status = BTA_AG_SUCCESS;
135 (*bta_ag_cb.p_cback)(BTA_AG_REGISTER_EVT, (tBTA_AG *) ®);
136 }
137
138 /*******************************************************************************
139 **
140 ** Function bta_ag_deregister
141 **
142 ** Description This function removes the sdp records, closes the RFCOMM
143 ** servers, and deallocates the service control block.
144 **
145 **
146 ** Returns void
147 **
148 *******************************************************************************/
bta_ag_deregister(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)149 void bta_ag_deregister(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
150 {
151 /* set dealloc */
152 p_scb->dealloc = TRUE;
153 /* remove sdp records */
154 bta_ag_del_records(p_scb, p_data);
155 /* remove rfcomm servers */
156 bta_ag_close_servers(p_scb, p_scb->reg_services);
157 /* dealloc */
158 bta_ag_scb_dealloc(p_scb);
159 }
160
161 /*******************************************************************************
162 **
163 ** Function bta_ag_start_dereg
164 **
165 ** Description Start a deregister event.
166 **
167 **
168 ** Returns void
169 **
170 *******************************************************************************/
bta_ag_start_dereg(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)171 void bta_ag_start_dereg(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
172 {
173 /* set dealloc */
174 p_scb->dealloc = TRUE;
175 /* remove sdp records */
176 bta_ag_del_records(p_scb, p_data);
177 }
178
179 /*******************************************************************************
180 **
181 ** Function bta_ag_start_open
182 **
183 ** Description This starts an AG open.
184 **
185 **
186 ** Returns void
187 **
188 *******************************************************************************/
bta_ag_start_open(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)189 void bta_ag_start_open(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
190 {
191 BD_ADDR pending_bd_addr;
192 /* store parameters */
193 if (p_data) {
194 bdcpy(p_scb->peer_addr, p_data->api_open.bd_addr);
195 p_scb->open_services = p_data->api_open.services;
196 p_scb->cli_sec_mask = p_data->api_open.sec_mask;
197 }
198 /* Check if RFCOMM has any incoming connection to avoid collision. */
199 if (PORT_IsOpening (pending_bd_addr)) {
200 /* Let the incoming connection goes through. */
201 /* Issue collision for this scb for now. */
202 /* We will decide what to do when we find incoming connetion later. */
203 bta_ag_collision_cback (0, BTA_ID_AG, 0, p_scb->peer_addr);
204 return;
205 }
206 /* close servers */
207 bta_ag_close_servers(p_scb, p_scb->reg_services);
208 /* set role */
209 p_scb->role = BTA_AG_INT;
210 /* do service search */
211 bta_ag_do_disc(p_scb, p_scb->open_services);
212 }
213
214 /*******************************************************************************
215 **
216 ** Function bta_ag_disc_int_res
217 **
218 ** Description This function handles a discovery result when initiator.
219 **
220 **
221 ** Returns void
222 **
223 *******************************************************************************/
bta_ag_disc_int_res(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)224 void bta_ag_disc_int_res(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
225 {
226 UINT16 event = BTA_AG_DISC_FAIL_EVT;
227 APPL_TRACE_DEBUG ("bta_ag_disc_int_res: Status: %d", p_data->disc_result.status);
228
229 /* if found service */
230 if (p_data->disc_result.status == SDP_SUCCESS ||
231 p_data->disc_result.status == SDP_DB_FULL) {
232 /* get attributes */
233 if (bta_ag_sdp_find_attr(p_scb, p_scb->open_services)) {
234 /* set connected service */
235 p_scb->conn_service = bta_ag_service_to_idx(p_scb->open_services);
236 /* send ourselves sdp ok event */
237 event = BTA_AG_DISC_OK_EVT;
238 }
239 }
240 /* free discovery db */
241 bta_ag_free_db(p_scb, p_data);
242 /* if service not found check if we should search for other service */
243 if ((event == BTA_AG_DISC_FAIL_EVT) &&
244 (p_data->disc_result.status == SDP_SUCCESS ||
245 p_data->disc_result.status == SDP_DB_FULL ||
246 p_data->disc_result.status == SDP_NO_RECS_MATCH)) {
247 if ((p_scb->open_services & BTA_HFP_SERVICE_MASK) &&
248 (p_scb->open_services & BTA_HSP_SERVICE_MASK)) {
249 /* search for HSP */
250 p_scb->open_services &= ~BTA_HFP_SERVICE_MASK;
251 bta_ag_do_disc(p_scb, p_scb->open_services);
252 } else if ((p_scb->open_services & BTA_HSP_SERVICE_MASK) &&
253 (p_scb->hsp_version == HSP_VERSION_1_2)) {
254 /* search for UUID_SERVCLASS_HEADSET for HSP 1.0 device */
255 p_scb->hsp_version = HSP_VERSION_1_0;
256 bta_ag_do_disc(p_scb, p_scb->open_services);
257 } else {
258 /* send ourselves sdp ok/fail event */
259 bta_ag_sm_execute(p_scb, event, p_data);
260 }
261 } else {
262 /* send ourselves sdp ok/fail event */
263 bta_ag_sm_execute(p_scb, event, p_data);
264 }
265 }
266
267 /*******************************************************************************
268 **
269 ** Function bta_ag_disc_acp_res
270 **
271 ** Description This function handles a discovery result when acceptor.
272 **
273 **
274 ** Returns void
275 **
276 *******************************************************************************/
bta_ag_disc_acp_res(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)277 void bta_ag_disc_acp_res(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
278 {
279 /* if found service */
280 if (p_data->disc_result.status == SDP_SUCCESS ||
281 p_data->disc_result.status == SDP_DB_FULL) {
282 /* get attributes */
283 bta_ag_sdp_find_attr(p_scb, bta_ag_svc_mask[p_scb->conn_service]);
284 }
285 /* free discovery db */
286 bta_ag_free_db(p_scb, p_data);
287 }
288
289 /*******************************************************************************
290 **
291 ** Function bta_ag_disc_fail
292 **
293 ** Description This function handles a discovery failure.
294 **
295 **
296 ** Returns void
297 **
298 *******************************************************************************/
bta_ag_disc_fail(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)299 void bta_ag_disc_fail(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
300 {
301 UNUSED(p_data);
302 /* reopen registered servers */
303 bta_ag_start_servers(p_scb, p_scb->reg_services);
304 /* reinitialize stuff */
305 /* call open cback w. failure */
306 bta_ag_cback_open(p_scb, NULL, BTA_AG_FAIL_SDP);
307 }
308
309 /*******************************************************************************
310 **
311 ** Function bta_ag_open_fail
312 **
313 ** Description open connection failed.
314 **
315 **
316 ** Returns void
317 **
318 *******************************************************************************/
bta_ag_open_fail(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)319 void bta_ag_open_fail(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
320 {
321 /* call open cback w. failure */
322 bta_ag_cback_open(p_scb, p_data, BTA_AG_FAIL_RESOURCES);
323 }
324
325 /*******************************************************************************
326 **
327 ** Function bta_ag_rfc_fail
328 **
329 ** Description RFCOMM connection failed.
330 **
331 **
332 ** Returns void
333 **
334 *******************************************************************************/
bta_ag_rfc_fail(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)335 void bta_ag_rfc_fail(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
336 {
337 UNUSED(p_data);
338 /* reinitialize stuff */
339 p_scb->conn_handle = 0;
340 p_scb->conn_service = 0;
341 p_scb->peer_features = 0;
342 #if (BTM_WBS_INCLUDED == TRUE)
343 p_scb->peer_codecs = BTA_AG_CODEC_NONE;
344 p_scb->sco_codec = BTA_AG_CODEC_NONE;
345 #endif
346 p_scb->role = 0;
347 p_scb->svc_conn = FALSE;
348 p_scb->hsp_version = HSP_VERSION_1_2;
349 /*Clear the BD address*/
350 bdcpy(p_scb->peer_addr, bd_addr_null);
351 /* reopen registered servers */
352 bta_ag_start_servers(p_scb, p_scb->reg_services);
353 /* call open cback w. failure */
354 bta_ag_cback_open(p_scb, NULL, BTA_AG_FAIL_RFCOMM);
355 }
356
357 /*******************************************************************************
358 **
359 ** Function bta_ag_rfc_close
360 **
361 ** Description RFCOMM connection closed.
362 **
363 **
364 ** Returns void
365 **
366 *******************************************************************************/
bta_ag_rfc_close(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)367 void bta_ag_rfc_close(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
368 {
369 tBTA_AG_CLOSE close;
370 tBTA_SERVICE_MASK services;
371 int i, num_active_conn = 0;
372 UNUSED(p_data);
373 /* reinitialize stuff */
374 p_scb->conn_service = 0;
375 p_scb->peer_features = 0;
376 #if (BTM_WBS_INCLUDED == TRUE)
377 p_scb->peer_codecs = BTA_AG_CODEC_NONE;
378 p_scb->sco_codec = BTA_AG_CODEC_NONE;
379 /* Clear these flags upon SLC teardown */
380 p_scb->codec_updated = FALSE;
381 p_scb->codec_fallback = FALSE;
382 p_scb->codec_msbc_settings = BTA_AG_SCO_MSBC_SETTINGS_T2;
383 #endif
384 p_scb->role = 0;
385 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
386 p_scb->svc_conn = FALSE;
387 p_scb->hsp_version = HSP_VERSION_1_2;
388 bta_ag_at_reinit(&p_scb->at_cb);
389 /* stop timers */
390 bta_sys_stop_timer(&p_scb->act_timer);
391 #if (BTM_WBS_INCLUDED == TRUE)
392 bta_sys_stop_timer(&p_scb->cn_timer);
393 #endif
394 close.hdr.handle = bta_ag_scb_to_idx(p_scb);
395 close.hdr.app_id = p_scb->app_id;
396 bdcpy(close.bd_addr, p_scb->peer_addr);
397
398 bta_sys_conn_close(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
399
400 /* call close cback */
401 (*bta_ag_cb.p_cback)(BTA_AG_CLOSE_EVT, (tBTA_AG *) &close);
402
403 /* if not deregistering (deallocating) reopen registered servers */
404 if (p_scb->dealloc == FALSE) {
405 /* Clear peer bd_addr so instance can be reused */
406 bdcpy(p_scb->peer_addr, bd_addr_null);
407
408 /* start only unopened server */
409 services = p_scb->reg_services;
410 for (i = 0; i < BTA_AG_NUM_IDX && services != 0; i++) {
411 if (p_scb->serv_handle[i]) {
412 services &= ~((tBTA_SERVICE_MASK)1 << (BTA_HSP_SERVICE_ID + i));
413 }
414 }
415 bta_ag_start_servers(p_scb, services);
416 p_scb->conn_handle = 0;
417 /* Make sure SCO state is BTA_AG_SCO_SHUTDOWN_ST */
418 bta_ag_sco_shutdown(p_scb, NULL);
419 /* Check if all the SLCs are down */
420 for (i = 0; i < BTA_AG_NUM_SCB; i++) {
421 if (bta_ag_cb.scb[i].in_use && bta_ag_cb.scb[i].svc_conn) {
422 num_active_conn++;
423 }
424 }
425 if (!num_active_conn) {
426 bta_sys_sco_unuse(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
427 }
428 } else {
429 /* else close port and deallocate scb */
430 RFCOMM_RemoveServer(p_scb->conn_handle);
431 bta_ag_scb_dealloc(p_scb);
432 }
433 }
434
435 /*******************************************************************************
436 **
437 ** Function bta_ag_rfc_open
438 **
439 ** Description Handle RFCOMM channel open.
440 **
441 **
442 ** Returns void
443 **
444 *******************************************************************************/
bta_ag_rfc_open(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)445 void bta_ag_rfc_open(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
446 {
447 /* initialize AT feature variables */
448 p_scb->clip_enabled = FALSE;
449 p_scb->ccwa_enabled = FALSE;
450 p_scb->cmer_enabled = FALSE;
451 p_scb->cmee_enabled = FALSE;
452 p_scb->inband_enabled = ((p_scb->features & BTA_AG_FEAT_INBAND) == BTA_AG_FEAT_INBAND);
453
454 /* set up AT command interpreter */
455 p_scb->at_cb.p_at_tbl = (tBTA_AG_AT_CMD *) bta_ag_at_tbl[p_scb->conn_service];
456 p_scb->at_cb.p_cmd_cback = (tBTA_AG_AT_CMD_CBACK *) bta_ag_at_cback_tbl[p_scb->conn_service];
457 p_scb->at_cb.p_err_cback = (tBTA_AG_AT_ERR_CBACK *) bta_ag_at_err_cback;
458 p_scb->at_cb.p_user = p_scb;
459 p_scb->at_cb.cmd_max_len = BTA_AG_CMD_MAX;
460 bta_ag_at_init(&p_scb->at_cb);
461
462 /* call app open call-out */
463 bta_sys_conn_open(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
464 bta_ag_cback_open(p_scb, NULL, BTA_AG_SUCCESS);
465
466 if (p_scb->conn_service == BTA_AG_HFP) {
467 /* if hfp start timer for service level conn */
468 bta_sys_start_timer(&p_scb->act_timer, BTA_AG_SVC_TOUT_EVT, p_bta_ag_cfg->conn_tout);
469 } else {
470 /* else service level conn is open */
471 bta_ag_svc_conn_open(p_scb, p_data);
472 }
473 }
474
475 /*******************************************************************************
476 **
477 ** Function bta_ag_rfc_acp_open
478 **
479 ** Description Handle RFCOMM channel open when accepting connection.
480 **
481 **
482 ** Returns void
483 **
484 *******************************************************************************/
bta_ag_rfc_acp_open(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)485 void bta_ag_rfc_acp_open(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
486 {
487 UINT16 lcid;
488 int i;
489 tBTA_AG_SCB *ag_scb, *other_scb;
490 BD_ADDR dev_addr = {0};
491 int status;
492 /* set role */
493 p_scb->role = BTA_AG_ACP;
494 APPL_TRACE_DEBUG ("bta_ag_rfc_acp_open: serv_handle0 = %d serv_handle1 = %d",
495 p_scb->serv_handle[0], p_scb->serv_handle[1]);
496 /* get bd addr of peer */
497 if (PORT_SUCCESS != (status = PORT_CheckConnection(p_data->rfc.port_handle, FALSE, dev_addr, &lcid))) {
498 APPL_TRACE_DEBUG ("bta_ag_rfc_acp_open error PORT_CheckConnection returned status %d", status);
499 }
500 /* Collision Handling */
501 for (i = 0, ag_scb = &bta_ag_cb.scb[0]; i < BTA_AG_NUM_SCB; i++, ag_scb++) {
502 if ((ag_scb->in_use) && (ag_scb->colli_tmr_on)) {
503 /* stop collision timer */
504 ag_scb->colli_tmr_on = FALSE;
505 bta_sys_stop_timer (&ag_scb->colli_timer);
506
507 if (bdcmp (dev_addr, ag_scb->peer_addr) == 0) {
508 /* If incoming and outgoing device are same, nothing more to do. */
509 /* Outgoing conn will be aborted because we have successful incoming conn. */
510 } else {
511 /* Resume outgoing connection. */
512 other_scb = bta_ag_get_other_idle_scb (p_scb);
513 if (other_scb) {
514 bdcpy(other_scb->peer_addr, ag_scb->peer_addr);
515 other_scb->open_services = ag_scb->open_services;
516 other_scb->cli_sec_mask = ag_scb->cli_sec_mask;
517 bta_ag_resume_open (other_scb);
518 }
519 }
520 break;
521 }
522 }
523 bdcpy (p_scb->peer_addr, dev_addr);
524 /* determine connected service from port handle */
525 for (i = 0; i < BTA_AG_NUM_IDX; i++) {
526 APPL_TRACE_DEBUG ("bta_ag_rfc_acp_open: i = %d serv_handle = %d port_handle = %d",
527 i, p_scb->serv_handle[i], p_data->rfc.port_handle);
528 if (p_scb->serv_handle[i] == p_data->rfc.port_handle) {
529 p_scb->conn_service = i;
530 p_scb->conn_handle = p_data->rfc.port_handle;
531 break;
532 }
533 }
534 APPL_TRACE_DEBUG ("bta_ag_rfc_acp_open: conn_service = %d conn_handle = %d",
535 p_scb->conn_service, p_scb->conn_handle);
536 /* close any unopened server */
537 bta_ag_close_servers(p_scb, (p_scb->reg_services & ~bta_ag_svc_mask[p_scb->conn_service]));
538 /* do service discovery to get features */
539 bta_ag_do_disc(p_scb, bta_ag_svc_mask[p_scb->conn_service]);
540 /* continue with common open processing */
541 bta_ag_rfc_open(p_scb, p_data);
542 }
543
544 /*******************************************************************************
545 **
546 ** Function bta_ag_rfc_data
547 **
548 ** Description Read and process data from RFCOMM.
549 **
550 **
551 ** Returns void
552 **
553 *******************************************************************************/
bta_ag_rfc_data(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)554 void bta_ag_rfc_data(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
555 {
556 UINT16 len;
557 char buf[BTA_AG_RFC_READ_MAX];
558 UNUSED(p_data);
559 memset(buf, 0, BTA_AG_RFC_READ_MAX);
560
561 APPL_TRACE_DEBUG("bta_ag_rfc_data");
562 /* do the following */
563 for (;;) {
564 /* read data from rfcomm; if bad status, we're done */
565 if (PORT_ReadData(p_scb->conn_handle, buf, BTA_AG_RFC_READ_MAX, &len) != PORT_SUCCESS) {
566 break;
567 }
568 /* if no data, we're done */
569 if (len == 0) {
570 break;
571 }
572 /* run AT command interpreter on data */
573 bta_sys_busy(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
574 bta_ag_at_parse(&p_scb->at_cb, buf, len);
575 bta_sys_idle(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
576 /* no more data to read, we're done */
577 if (len < BTA_AG_RFC_READ_MAX) {
578 break;
579 }
580 }
581 }
582
583 /*******************************************************************************
584 **
585 ** Function bta_ag_start_close
586 **
587 ** Description Start the process of closing SCO and RFCOMM connection.
588 **
589 **
590 ** Returns void
591 **
592 *******************************************************************************/
bta_ag_start_close(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)593 void bta_ag_start_close(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
594 {
595 /* Take the link out of sniff and set L2C idle time to 0 */
596 bta_dm_pm_active(p_scb->peer_addr);
597 L2CA_SetIdleTimeoutByBdAddr(p_scb->peer_addr, 0, BT_TRANSPORT_BR_EDR);
598 /* if SCO is open close SCO and wait on RFCOMM close */
599 if (bta_ag_sco_is_open(p_scb)) {
600 p_scb->post_sco = BTA_AG_POST_SCO_CLOSE_RFC;
601 } else {
602 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
603 bta_ag_rfc_do_close(p_scb, p_data);
604 }
605 /* Always do SCO shutdown to handle all SCO corner cases */
606 bta_ag_sco_shutdown(p_scb, p_data);
607 }
608
609 /*******************************************************************************
610 **
611 ** Function bta_ag_post_sco_open
612 **
613 ** Description Perform post-SCO open action, if any
614 **
615 **
616 ** Returns void
617 **
618 *******************************************************************************/
bta_ag_post_sco_open(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)619 void bta_ag_post_sco_open(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
620 {
621 switch (p_scb->post_sco) {
622 case BTA_AG_POST_SCO_RING:
623 bta_ag_send_ring(p_scb, p_data);
624 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
625 break;
626
627 case BTA_AG_POST_SCO_CALL_CONN:
628 bta_ag_send_call_inds(p_scb, BTA_AG_IN_CALL_CONN_RES);
629 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
630 break;
631
632 default:
633 break;
634 }
635 }
636
637 /*******************************************************************************
638 **
639 ** Function bta_ag_post_sco_close
640 **
641 ** Description Perform post-SCO close action, if any
642 **
643 **
644 ** Returns void
645 **
646 *******************************************************************************/
bta_ag_post_sco_close(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)647 void bta_ag_post_sco_close(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
648 {
649 switch (p_scb->post_sco) {
650 case BTA_AG_POST_SCO_CLOSE_RFC:
651 bta_ag_rfc_do_close(p_scb, p_data);
652 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
653 break;
654
655 case BTA_AG_POST_SCO_CALL_CONN:
656 bta_ag_send_call_inds(p_scb, BTA_AG_IN_CALL_CONN_RES);
657 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
658 break;
659
660 case BTA_AG_POST_SCO_CALL_ORIG:
661 bta_ag_send_call_inds(p_scb, BTA_AG_OUT_CALL_ORIG_RES);
662 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
663 break;
664
665 case BTA_AG_POST_SCO_CALL_END:
666 bta_ag_send_call_inds(p_scb, BTA_AG_END_CALL_RES);
667 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
668 break;
669
670 case BTA_AG_POST_SCO_CALL_END_INCALL:
671 {
672 bta_ag_send_call_inds(p_scb, BTA_AG_END_CALL_RES);
673 /* Sending callsetup IND and Ring were defered to after SCO close. */
674 bta_ag_send_call_inds(p_scb, BTA_AG_IN_CALL_RES);
675
676 if (bta_ag_inband_enabled(p_scb) && !(p_scb->features & BTA_AG_FEAT_NOSCO)) {
677 p_scb->post_sco = BTA_AG_POST_SCO_RING;
678 bta_ag_sco_open(p_scb, p_data);
679 } else {
680 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
681 bta_ag_send_ring(p_scb, p_data);
682 }
683 break;
684 }
685
686 default:
687 break;
688 }
689 }
690
691 /*******************************************************************************
692 **
693 ** Function bta_ag_svc_conn_open
694 **
695 ** Description Service level connection opened
696 **
697 **
698 ** Returns void
699 **
700 *******************************************************************************/
bta_ag_svc_conn_open(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)701 void bta_ag_svc_conn_open(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
702 {
703 tBTA_AG_CONN evt;
704 UNUSED(p_data);
705
706 if (!p_scb->svc_conn) {
707 /* set state variable */
708 p_scb->svc_conn = TRUE;
709 /* Clear AT+BIA mask from previous SLC if any. */
710 p_scb->bia_masked_out = 0;
711 /* stop timer */
712 bta_sys_stop_timer(&p_scb->act_timer);
713 /* call callback */
714 evt.hdr.handle = bta_ag_scb_to_idx(p_scb);
715 evt.hdr.app_id = p_scb->app_id;
716 evt.peer_feat = p_scb->peer_features;
717 bdcpy(evt.bd_addr, p_scb->peer_addr);
718 #if (BTM_WBS_INCLUDED == TRUE)
719 evt.peer_codec = p_scb->peer_codecs;
720 #endif
721 if ((p_scb->call_ind != BTA_AG_CALL_INACTIVE) ||
722 (p_scb->callsetup_ind != BTA_AG_CALLSETUP_NONE)) {
723 bta_sys_sco_use(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
724 }
725 (*bta_ag_cb.p_cback)(BTA_AG_CONN_EVT, (tBTA_AG *) &evt);
726 }
727 }
728
729 /*******************************************************************************
730 **
731 ** Function bta_ag_ci_rx_data
732 **
733 ** Description Send result code to RFCOMM
734 **
735 ** Returns void
736 **
737 *******************************************************************************/
bta_ag_ci_rx_data(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)738 void bta_ag_ci_rx_data(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
739 {
740 UINT16 len;
741 tBTA_AG_CI_RX_WRITE *p_rx_write_msg = (tBTA_AG_CI_RX_WRITE *)p_data;
742 char *p_data_area = (char *)(p_rx_write_msg+1); /* Point to data area after header */
743
744 APPL_TRACE_DEBUG("bta_ag_ci_rx_data:");
745 /* send to RFCOMM */
746 bta_sys_busy(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
747 PORT_WriteData(p_scb->conn_handle, p_data_area, strlen(p_data_area), &len);
748 bta_sys_idle(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
749 }
750
751 /*******************************************************************************
752 **
753 ** Function bta_ag_rcvd_slc_ready
754 **
755 ** Description Handles SLC ready call-in in case of pass-through mode.
756 **
757 ** Returns void
758 **
759 *******************************************************************************/
bta_ag_rcvd_slc_ready(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)760 void bta_ag_rcvd_slc_ready(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
761 {
762 UNUSED(p_data);
763 APPL_TRACE_DEBUG("bta_ag_rcvd_slc_ready: handle = %d", bta_ag_scb_to_idx(p_scb));
764
765 if (bta_ag_cb.parse_mode == BTA_AG_PASS_THROUGH) {
766 /* In pass-through mode, BTA knows that SLC is ready only through call-in. */
767 bta_ag_svc_conn_open(p_scb, NULL);
768 }
769 }
770
771 /*******************************************************************************
772 **
773 ** Function bta_ag_setcodec
774 **
775 ** Description Handle API SetCodec
776 **
777 **
778 ** Returns void
779 **
780 *******************************************************************************/
bta_ag_setcodec(tBTA_AG_SCB * p_scb,tBTA_AG_DATA * p_data)781 void bta_ag_setcodec(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data)
782 {
783 #if (BTM_WBS_INCLUDED == TRUE)
784 UINT16 handle = p_data->api_setcodec.hdr.layer_specific;
785 tBTA_AG_PEER_CODEC codec_type = p_data->api_setcodec.codec;
786 tBTA_AG_VAL val;
787
788 val.hdr.handle = handle;
789 val.num = codec_type;
790
791 /* Check if the requested codec type is valid */
792 if((codec_type != BTA_AG_CODEC_NONE) &&
793 (codec_type != BTA_AG_CODEC_CVSD) &&
794 (codec_type != BTA_AG_CODEC_MSBC)) {
795 val.hdr.status = BTA_AG_FAIL_RESOURCES;
796 APPL_TRACE_ERROR("%s error: unsupported codec type %d", __func__, codec_type);
797 (*bta_ag_cb.p_cback)(BTA_AG_WBS_EVT, (tBTA_AG *) &val);
798 return;
799 }
800
801 if ((p_scb->peer_codecs & codec_type) ||
802 (codec_type == BTA_AG_CODEC_NONE) ||
803 (codec_type == BTA_AG_CODEC_CVSD)) {
804 p_scb->sco_codec = codec_type;
805 p_scb->codec_updated = TRUE;
806 val.hdr.status = BTA_AG_SUCCESS;
807 APPL_TRACE_DEBUG("%s: Updated codec type %d", __func__, codec_type);
808 } else {
809 val.hdr.status = BTA_AG_FAIL_RESOURCES;
810 APPL_TRACE_ERROR("%s error: unsupported codec type %d",__func__, codec_type);
811 }
812 (*bta_ag_cb.p_cback)(BTA_AG_WBS_EVT, (tBTA_AG *) &val);
813 #endif
814 }
815
816 #endif /* #if (BTA_AG_INCLUDED == TRUE) */
817
