bta/ag/bta_ag_act.c

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