bta/hf_client/bta_hf_client_sco.cc

   1 /******************************************************************************
   2  *
   3  *  Copyright (c) 2014 The Android Open Source Project
   4  *  Copyright 2004-2012 Broadcom Corporation
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at:
   9  *
  10  *  http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License.
  17  *
  18  ******************************************************************************/
  19 #include <string.h>
  20
  21 #include "bt_trace.h"
  22 #include "bt_utils.h"
  23 #include "bta_ag_api.h"
  24 #include "bta_hf_client_int.h"
  25 #include "device/include/esco_parameters.h"
  26 #include "osi/include/osi.h"
  27
  28 #define BTA_HF_CLIENT_NO_EDR_ESCO                                \
  29   (ESCO_PKT_TYPES_MASK_NO_2_EV3 | ESCO_PKT_TYPES_MASK_NO_3_EV3 | \
  30    ESCO_PKT_TYPES_MASK_NO_2_EV5 | ESCO_PKT_TYPES_MASK_NO_3_EV5)
  31
  32 enum {
  33   BTA_HF_CLIENT_SCO_LISTEN_E,
  34   BTA_HF_CLIENT_SCO_OPEN_E,       /* open request */
  35   BTA_HF_CLIENT_SCO_CLOSE_E,      /* close request */
  36   BTA_HF_CLIENT_SCO_SHUTDOWN_E,   /* shutdown request */
  37   BTA_HF_CLIENT_SCO_CONN_OPEN_E,  /* SCO opened */
  38   BTA_HF_CLIENT_SCO_CONN_CLOSE_E, /* SCO closed */
  39 };
  40
  41 /*******************************************************************************
  42  *
  43  * Function         bta_hf_client_remove_sco
  44  *
  45  * Description      Removes the specified SCO from the system.
  46  *
  47  * Returns          bool   - true if SCO removal was started
  48  *
  49  ******************************************************************************/
  50 static bool bta_hf_client_sco_remove(tBTA_HF_CLIENT_CB* client_cb) {
  51   bool removed_started = false;
  52   tBTM_STATUS status;
  53
  54   APPL_TRACE_DEBUG("%s", __func__);
  55
  56   if (client_cb->sco_idx != BTM_INVALID_SCO_INDEX) {
  57     status = BTM_RemoveSco(client_cb->sco_idx);
  58
  59     APPL_TRACE_DEBUG("%s: idx 0x%04x, status:0x%x", __func__,
  60                      client_cb->sco_idx, status);
  61
  62     if (status == BTM_CMD_STARTED) {
  63       removed_started = true;
  64     }
  65     /* If no connection reset the SCO handle */
  66     else if ((status == BTM_SUCCESS) || (status == BTM_UNKNOWN_ADDR)) {
  67       client_cb->sco_idx = BTM_INVALID_SCO_INDEX;
  68     }
  69   }
  70   return removed_started;
  71 }
  72
  73 /*******************************************************************************
  74  *
  75  * Function         bta_hf_client_cback_sco
  76  *
  77  * Description      Call application callback function with SCO event.
  78  *
  79  *
  80  * Returns          void
  81  *
  82  ******************************************************************************/
  83 void bta_hf_client_cback_sco(tBTA_HF_CLIENT_CB* client_cb, uint8_t event) {
  84   tBTA_HF_CLIENT evt;
  85
  86   memset(&evt, 0, sizeof(evt));
  87   evt.bd_addr = client_cb->peer_addr;
  88
  89   /* call app cback */
  90   bta_hf_client_app_callback(event, &evt);
  91 }
  92
  93 /*******************************************************************************
  94  *
  95  * Function         bta_hf_client_sco_conn_rsp
  96  *
  97  * Description      Process the SCO connection request
  98  *
  99  *
 100  * Returns          void
 101  *
 102  ******************************************************************************/
 103 static void bta_hf_client_sco_conn_rsp(tBTA_HF_CLIENT_CB* client_cb,
 104                                        tBTM_ESCO_CONN_REQ_EVT_DATA* p_data) {
 105   enh_esco_params_t resp;
 106   uint8_t hci_status = HCI_SUCCESS;
 107
 108   APPL_TRACE_DEBUG("%s", __func__);
 109
 110   if (client_cb->sco_state == BTA_HF_CLIENT_SCO_LISTEN_ST) {
 111     if (p_data->link_type == BTM_LINK_TYPE_SCO) {
 112       resp = esco_parameters_for_codec(ESCO_CODEC_CVSD);
 113     } else {
 114       if (client_cb->negotiated_codec == BTA_AG_CODEC_MSBC) {
 115         resp = esco_parameters_for_codec(ESCO_CODEC_MSBC_T2);
 116       } else {
 117         // default codec
 118         resp = esco_parameters_for_codec(ESCO_CODEC_CVSD);
 119       }
 120     }
 121
 122     /* tell sys to stop av if any */
 123     bta_sys_sco_use(BTA_ID_HS, 1, client_cb->peer_addr);
 124   } else {
 125     hci_status = HCI_ERR_HOST_REJECT_DEVICE;
 126   }
 127
 128   BTM_EScoConnRsp(p_data->sco_inx, hci_status, &resp);
 129 }
 130
 131 /*******************************************************************************
 132  *
 133  * Function         bta_hf_client_sco_connreq_cback
 134  *
 135  * Description      BTM eSCO connection requests and eSCO change requests
 136  *                  Only the connection requests are processed by BTA.
 137  *
 138  * Returns          void
 139  *
 140  ******************************************************************************/
 141 static void bta_hf_client_esco_connreq_cback(tBTM_ESCO_EVT event,
 142                                              tBTM_ESCO_EVT_DATA* p_data) {
 143   APPL_TRACE_DEBUG("%s: %d", __func__, event);
 144
 145   tBTA_HF_CLIENT_CB* client_cb =
 146       bta_hf_client_find_cb_by_sco_handle(p_data->conn_evt.sco_inx);
 147   if (client_cb == NULL) {
 148     APPL_TRACE_ERROR("%s: wrong SCO handle to control block %d", __func__,
 149                      p_data->conn_evt.sco_inx);
 150     return;
 151   }
 152
 153   if (event != BTM_ESCO_CONN_REQ_EVT) {
 154     return;
 155   }
 156
 157   bta_hf_client_sco_conn_rsp(client_cb, &p_data->conn_evt);
 158
 159   client_cb->sco_state = BTA_HF_CLIENT_SCO_OPENING_ST;
 160 }
 161
 162 /*******************************************************************************
 163  *
 164  * Function         bta_hf_client_sco_conn_cback
 165  *
 166  * Description      BTM SCO connection callback.
 167  *
 168  *
 169  * Returns          void
 170  *
 171  ******************************************************************************/
 172 static void bta_hf_client_sco_conn_cback(uint16_t sco_idx) {
 173   APPL_TRACE_DEBUG("%s: %d", __func__, sco_idx);
 174
 175   tBTA_HF_CLIENT_CB* client_cb = bta_hf_client_find_cb_by_sco_handle(sco_idx);
 176   if (client_cb == NULL) {
 177     APPL_TRACE_ERROR("%s: wrong SCO handle to control block %d", __func__,
 178                      sco_idx);
 179     return;
 180   }
 181
 182   BT_HDR* p_buf = (BT_HDR*)osi_malloc(sizeof(BT_HDR));
 183   p_buf->event = BTA_HF_CLIENT_SCO_OPEN_EVT;
 184   p_buf->layer_specific = client_cb->handle;
 185   bta_sys_sendmsg(p_buf);
 186 }
 187
 188 /*******************************************************************************
 189  *
 190  * Function         bta_hf_client_sco_disc_cback
 191  *
 192  * Description      BTM SCO disconnection callback.
 193  *
 194  *
 195  * Returns          void
 196  *
 197  ******************************************************************************/
 198 static void bta_hf_client_sco_disc_cback(uint16_t sco_idx) {
 199   APPL_TRACE_DEBUG("%s: sco_idx %d", __func__, sco_idx);
 200
 201   tBTA_HF_CLIENT_CB* client_cb = bta_hf_client_find_cb_by_sco_handle(sco_idx);
 202   if (client_cb == NULL) {
 203     APPL_TRACE_ERROR("%s: wrong handle to control block %d", __func__, sco_idx);
 204     return;
 205   }
 206
 207   BT_HDR* p_buf = (BT_HDR*)osi_malloc(sizeof(BT_HDR));
 208   p_buf->event = BTA_HF_CLIENT_SCO_CLOSE_EVT;
 209   p_buf->layer_specific = client_cb->handle;
 210   bta_sys_sendmsg(p_buf);
 211 }
 212
 213 /*******************************************************************************
 214  *
 215  * Function         bta_hf_client_create_sco
 216  *
 217  * Description
 218  *
 219  *
 220  * Returns          void
 221  *
 222  ******************************************************************************/
 223 static void bta_hf_client_sco_create(tBTA_HF_CLIENT_CB* client_cb,
 224                                      bool is_orig) {
 225   tBTM_STATUS status;
 226
 227   APPL_TRACE_DEBUG("%s: %d", __func__, is_orig);
 228
 229   /* Make sure this SCO handle is not already in use */
 230   if (client_cb->sco_idx != BTM_INVALID_SCO_INDEX) {
 231     APPL_TRACE_WARNING("%s: Index 0x%04x already in use", __func__,
 232                        client_cb->sco_idx);
 233     return;
 234   }
 235
 236   enh_esco_params_t params = esco_parameters_for_codec(ESCO_CODEC_CVSD);
 237
 238   /* if initiating set current scb and peer bd addr */
 239   if (is_orig) {
 240     BTM_SetEScoMode(&params);
 241     /* tell sys to stop av if any */
 242     bta_sys_sco_use(BTA_ID_HS, 1, client_cb->peer_addr);
 243   }
 244
 245   status = BTM_CreateSco(&client_cb->peer_addr, is_orig, params.packet_types,
 246                          &client_cb->sco_idx, bta_hf_client_sco_conn_cback,
 247                          bta_hf_client_sco_disc_cback);
 248   if (status == BTM_CMD_STARTED && !is_orig) {
 249     if (!BTM_RegForEScoEvts(client_cb->sco_idx,
 250                             bta_hf_client_esco_connreq_cback))
 251       APPL_TRACE_DEBUG("%s: SCO registration success", __func__);
 252   }
 253
 254   APPL_TRACE_API("%s: orig %d, inx 0x%04x, status 0x%x, pkt types 0x%04x",
 255                  __func__, is_orig, client_cb->sco_idx, status,
 256                  params.packet_types);
 257 }
 258
 259 /*******************************************************************************
 260  *
 261  * Function         bta_hf_client_sco_event
 262  *
 263  * Description      Handle SCO events
 264  *
 265  *
 266  * Returns          void
 267  *
 268  ******************************************************************************/
 269 static void bta_hf_client_sco_event(tBTA_HF_CLIENT_CB* client_cb,
 270                                     uint8_t event) {
 271   APPL_TRACE_DEBUG("%s: before state: %d event: %d", __func__,
 272                    client_cb->sco_state, event);
 273
 274   switch (client_cb->sco_state) {
 275     case BTA_HF_CLIENT_SCO_SHUTDOWN_ST:
 276       switch (event) {
 277         // For WBS we only listen to SCO requests. Even for outgoing SCO
 278         // requests we first do a AT+BCC and wait for remote to initiate SCO
 279         case BTA_HF_CLIENT_SCO_LISTEN_E:
 280           /* create SCO listen connection */
 281           bta_hf_client_sco_create(client_cb, false);
 282           client_cb->sco_state = BTA_HF_CLIENT_SCO_LISTEN_ST;
 283           break;
 284
 285         // For non WBS cases and enabling outgoing SCO requests we need to force
 286         // open a SCO channel
 287         case BTA_HF_CLIENT_SCO_OPEN_E:
 288           /* remove listening connection */
 289           bta_hf_client_sco_remove(client_cb);
 290
 291           /* create SCO connection to peer */
 292           bta_hf_client_sco_create(client_cb, true);
 293           client_cb->sco_state = BTA_HF_CLIENT_SCO_OPENING_ST;
 294           break;
 295
 296         default:
 297           APPL_TRACE_WARNING("BTA_HF_CLIENT_SCO_SHUTDOWN_ST: Ignoring event %d",
 298                              event);
 299           break;
 300       }
 301       break;
 302
 303     case BTA_HF_CLIENT_SCO_LISTEN_ST:
 304       switch (event) {
 305         case BTA_HF_CLIENT_SCO_LISTEN_E:
 306           /* create SCO listen connection */
 307           bta_hf_client_sco_create(client_cb, false);
 308
 309         case BTA_HF_CLIENT_SCO_OPEN_E:
 310           /* remove listening connection */
 311           bta_hf_client_sco_remove(client_cb);
 312
 313           /* create SCO connection to peer */
 314           bta_hf_client_sco_create(client_cb, true);
 315           client_cb->sco_state = BTA_HF_CLIENT_SCO_OPENING_ST;
 316           break;
 317
 318         case BTA_HF_CLIENT_SCO_SHUTDOWN_E:
 319         case BTA_HF_CLIENT_SCO_CLOSE_E:
 320           /* remove listening connection */
 321           bta_hf_client_sco_remove(client_cb);
 322
 323           client_cb->sco_state = BTA_HF_CLIENT_SCO_SHUTDOWN_ST;
 324           break;
 325
 326         case BTA_HF_CLIENT_SCO_CONN_CLOSE_E:
 327           /* SCO failed; create SCO listen connection */
 328           bta_hf_client_sco_create(client_cb, false);
 329           client_cb->sco_state = BTA_HF_CLIENT_SCO_LISTEN_ST;
 330           break;
 331
 332         default:
 333           APPL_TRACE_WARNING(
 334               "%s: BTA_HF_CLIENT_SCO_LISTEN_ST: Ignoring event %d", __func__,
 335               event);
 336           break;
 337       }
 338       break;
 339
 340     case BTA_HF_CLIENT_SCO_OPENING_ST:
 341       switch (event) {
 342         case BTA_HF_CLIENT_SCO_CLOSE_E:
 343           client_cb->sco_state = BTA_HF_CLIENT_SCO_OPEN_CL_ST;
 344           break;
 345
 346         case BTA_HF_CLIENT_SCO_SHUTDOWN_E:
 347           client_cb->sco_state = BTA_HF_CLIENT_SCO_SHUTTING_ST;
 348           break;
 349
 350         case BTA_HF_CLIENT_SCO_CONN_OPEN_E:
 351           client_cb->sco_state = BTA_HF_CLIENT_SCO_OPEN_ST;
 352           break;
 353
 354         case BTA_HF_CLIENT_SCO_CONN_CLOSE_E:
 355           /* SCO failed; create SCO listen connection */
 356           bta_hf_client_sco_create(client_cb, false);
 357           client_cb->sco_state = BTA_HF_CLIENT_SCO_LISTEN_ST;
 358           break;
 359
 360         default:
 361           APPL_TRACE_WARNING("BTA_HF_CLIENT_SCO_OPENING_ST: Ignoring event %d",
 362                              event);
 363           break;
 364       }
 365       break;
 366
 367     case BTA_HF_CLIENT_SCO_OPEN_CL_ST:
 368       switch (event) {
 369         case BTA_HF_CLIENT_SCO_OPEN_E:
 370           client_cb->sco_state = BTA_HF_CLIENT_SCO_OPENING_ST;
 371           break;
 372
 373         case BTA_HF_CLIENT_SCO_SHUTDOWN_E:
 374           client_cb->sco_state = BTA_HF_CLIENT_SCO_SHUTTING_ST;
 375           break;
 376
 377         case BTA_HF_CLIENT_SCO_CONN_OPEN_E:
 378           /* close SCO connection */
 379           bta_hf_client_sco_remove(client_cb);
 380
 381           client_cb->sco_state = BTA_HF_CLIENT_SCO_CLOSING_ST;
 382           break;
 383
 384         case BTA_HF_CLIENT_SCO_CONN_CLOSE_E:
 385           /* SCO failed; create SCO listen connection */
 386
 387           client_cb->sco_state = BTA_HF_CLIENT_SCO_LISTEN_ST;
 388           break;
 389
 390         default:
 391           APPL_TRACE_WARNING("BTA_HF_CLIENT_SCO_OPEN_CL_ST: Ignoring event %d",
 392                              event);
 393           break;
 394       }
 395       break;
 396
 397     case BTA_HF_CLIENT_SCO_OPEN_ST:
 398       switch (event) {
 399         case BTA_HF_CLIENT_SCO_CLOSE_E:
 400           if (bta_hf_client_sco_remove(client_cb)) {
 401             client_cb->sco_state = BTA_HF_CLIENT_SCO_CLOSING_ST;
 402           }
 403           break;
 404
 405         case BTA_HF_CLIENT_SCO_SHUTDOWN_E:
 406           /* remove listening connection */
 407           bta_hf_client_sco_remove(client_cb);
 408
 409           client_cb->sco_state = BTA_HF_CLIENT_SCO_SHUTTING_ST;
 410           break;
 411
 412         case BTA_HF_CLIENT_SCO_CONN_CLOSE_E:
 413           /* peer closed SCO */
 414           bta_hf_client_sco_create(client_cb, false);
 415           client_cb->sco_state = BTA_HF_CLIENT_SCO_LISTEN_ST;
 416           break;
 417
 418         default:
 419           APPL_TRACE_WARNING("BTA_HF_CLIENT_SCO_OPEN_ST: Ignoring event %d",
 420                              event);
 421           break;
 422       }
 423       break;
 424
 425     case BTA_HF_CLIENT_SCO_CLOSING_ST:
 426       switch (event) {
 427         case BTA_HF_CLIENT_SCO_OPEN_E:
 428           client_cb->sco_state = BTA_HF_CLIENT_SCO_CLOSE_OP_ST;
 429           break;
 430
 431         case BTA_HF_CLIENT_SCO_SHUTDOWN_E:
 432           client_cb->sco_state = BTA_HF_CLIENT_SCO_SHUTTING_ST;
 433           break;
 434
 435         case BTA_HF_CLIENT_SCO_CONN_CLOSE_E:
 436           /* peer closed sco; create SCO listen connection */
 437           bta_hf_client_sco_create(client_cb, false);
 438           client_cb->sco_state = BTA_HF_CLIENT_SCO_LISTEN_ST;
 439           break;
 440
 441         default:
 442           APPL_TRACE_WARNING("BTA_HF_CLIENT_SCO_CLOSING_ST: Ignoring event %d",
 443                              event);
 444           break;
 445       }
 446       break;
 447
 448     case BTA_HF_CLIENT_SCO_CLOSE_OP_ST:
 449       switch (event) {
 450         case BTA_HF_CLIENT_SCO_CLOSE_E:
 451           client_cb->sco_state = BTA_HF_CLIENT_SCO_CLOSING_ST;
 452           break;
 453
 454         case BTA_HF_CLIENT_SCO_SHUTDOWN_E:
 455           client_cb->sco_state = BTA_HF_CLIENT_SCO_SHUTTING_ST;
 456           break;
 457
 458         case BTA_HF_CLIENT_SCO_CONN_CLOSE_E:
 459           /* open SCO connection */
 460           bta_hf_client_sco_create(client_cb, true);
 461           client_cb->sco_state = BTA_HF_CLIENT_SCO_OPENING_ST;
 462           break;
 463
 464         default:
 465           APPL_TRACE_WARNING("BTA_HF_CLIENT_SCO_CLOSE_OP_ST: Ignoring event %d",
 466                              event);
 467           break;
 468       }
 469       break;
 470
 471     case BTA_HF_CLIENT_SCO_SHUTTING_ST:
 472       switch (event) {
 473         case BTA_HF_CLIENT_SCO_CONN_OPEN_E:
 474           /* close SCO connection; wait for conn close event */
 475           bta_hf_client_sco_remove(client_cb);
 476           break;
 477
 478         case BTA_HF_CLIENT_SCO_CONN_CLOSE_E:
 479           client_cb->sco_state = BTA_HF_CLIENT_SCO_SHUTDOWN_ST;
 480           break;
 481
 482         case BTA_HF_CLIENT_SCO_SHUTDOWN_E:
 483           client_cb->sco_state = BTA_HF_CLIENT_SCO_SHUTDOWN_ST;
 484           break;
 485
 486         default:
 487           APPL_TRACE_WARNING("BTA_HF_CLIENT_SCO_SHUTTING_ST: Ignoring event %d",
 488                              event);
 489           break;
 490       }
 491       break;
 492
 493     default:
 494       break;
 495   }
 496
 497   APPL_TRACE_DEBUG("%s: after state: %d", __func__, client_cb->sco_state);
 498 }
 499
 500 /*******************************************************************************
 501  *
 502  * Function         bta_hf_client_sco_listen
 503  *
 504  * Description      Initialize SCO listener
 505  *
 506  *
 507  * Returns          void
 508  *
 509  ******************************************************************************/
 510 void bta_hf_client_sco_listen(tBTA_HF_CLIENT_DATA* p_data) {
 511   APPL_TRACE_DEBUG("%s", __func__);
 512
 513   tBTA_HF_CLIENT_CB* client_cb =
 514       bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);
 515   if (client_cb == NULL) {
 516     APPL_TRACE_ERROR("%s: wrong handle to control block %d", __func__,
 517                      p_data->hdr.layer_specific);
 518     return;
 519   }
 520
 521   bta_hf_client_sco_event(client_cb, BTA_HF_CLIENT_SCO_LISTEN_E);
 522 }
 523
 524 /*******************************************************************************
 525  *
 526  * Function         bta_hf_client_sco_shutdown
 527  *
 528  * Description
 529  *
 530  *
 531  * Returns          void
 532  *
 533  ******************************************************************************/
 534 void bta_hf_client_sco_shutdown(tBTA_HF_CLIENT_CB* client_cb) {
 535   APPL_TRACE_DEBUG("%s", __func__);
 536
 537   bta_hf_client_sco_event(client_cb, BTA_HF_CLIENT_SCO_SHUTDOWN_E);
 538 }
 539
 540 /*******************************************************************************
 541  *
 542  * Function         bta_hf_client_sco_conn_open
 543  *
 544  * Description
 545  *
 546  *
 547  * Returns          void
 548  *
 549  ******************************************************************************/
 550 void bta_hf_client_sco_conn_open(tBTA_HF_CLIENT_DATA* p_data) {
 551   APPL_TRACE_DEBUG("%s", __func__);
 552
 553   tBTA_HF_CLIENT_CB* client_cb =
 554       bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);
 555   if (client_cb == NULL) {
 556     APPL_TRACE_ERROR("%s: wrong handle to control block %d", __func__,
 557                      p_data->hdr.layer_specific);
 558     return;
 559   }
 560
 561   bta_hf_client_sco_event(client_cb, BTA_HF_CLIENT_SCO_CONN_OPEN_E);
 562
 563   bta_sys_sco_open(BTA_ID_HS, 1, client_cb->peer_addr);
 564
 565   if (client_cb->negotiated_codec == BTM_SCO_CODEC_MSBC) {
 566     bta_hf_client_cback_sco(client_cb, BTA_HF_CLIENT_AUDIO_MSBC_OPEN_EVT);
 567   } else {
 568     bta_hf_client_cback_sco(client_cb, BTA_HF_CLIENT_AUDIO_OPEN_EVT);
 569   }
 570 }
 571
 572 /*******************************************************************************
 573  *
 574  * Function         bta_hf_client_sco_conn_close
 575  *
 576  * Description
 577  *
 578  *
 579  * Returns          void
 580  *
 581  ******************************************************************************/
 582 void bta_hf_client_sco_conn_close(tBTA_HF_CLIENT_DATA* p_data) {
 583   APPL_TRACE_DEBUG("%s", __func__);
 584
 585   tBTA_HF_CLIENT_CB* client_cb =
 586       bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);
 587   if (client_cb == NULL) {
 588     APPL_TRACE_ERROR("%s: wrong handle to control block %d", __func__,
 589                      p_data->hdr.layer_specific);
 590     return;
 591   }
 592
 593   /* clear current scb */
 594   client_cb->sco_idx = BTM_INVALID_SCO_INDEX;
 595
 596   bta_hf_client_sco_event(client_cb, BTA_HF_CLIENT_SCO_CONN_CLOSE_E);
 597
 598   bta_sys_sco_close(BTA_ID_HS, 1, client_cb->peer_addr);
 599
 600   bta_sys_sco_unuse(BTA_ID_HS, 1, client_cb->peer_addr);
 601
 602   /* call app callback */
 603   bta_hf_client_cback_sco(client_cb, BTA_HF_CLIENT_AUDIO_CLOSE_EVT);
 604
 605   if (client_cb->sco_close_rfc) {
 606     client_cb->sco_close_rfc = false;
 607     bta_hf_client_rfc_do_close(p_data);
 608   }
 609 }
 610
 611 /*******************************************************************************
 612  *
 613  * Function         bta_hf_client_sco_open
 614  *
 615  * Description
 616  *
 617  *
 618  * Returns          void
 619  *
 620  ******************************************************************************/
 621 void bta_hf_client_sco_open(tBTA_HF_CLIENT_DATA* p_data) {
 622   APPL_TRACE_DEBUG("%s", __func__);
 623
 624   tBTA_HF_CLIENT_CB* client_cb =
 625       bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);
 626   if (client_cb == NULL) {
 627     APPL_TRACE_ERROR("%s: wrong handle to control block %d", __func__,
 628                      p_data->hdr.layer_specific);
 629     return;
 630   }
 631
 632   bta_hf_client_sco_event(client_cb, BTA_HF_CLIENT_SCO_OPEN_E);
 633 }
 634
 635 /*******************************************************************************
 636  *
 637  * Function         bta_hf_client_sco_close
 638  *
 639  * Description
 640  *
 641  *
 642  * Returns          void
 643  *
 644  ******************************************************************************/
 645 void bta_hf_client_sco_close(tBTA_HF_CLIENT_DATA* p_data) {
 646   tBTA_HF_CLIENT_CB* client_cb =
 647       bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);
 648   if (client_cb == NULL) {
 649     APPL_TRACE_ERROR("%s: wrong handle to control block %d", __func__,
 650                      p_data->hdr.layer_specific);
 651     return;
 652   }
 653
 654   APPL_TRACE_DEBUG("%s: sco_idx 0x%x", __func__, client_cb->sco_idx);
 655
 656   if (client_cb->sco_idx != BTM_INVALID_SCO_INDEX) {
 657     bta_hf_client_sco_event(client_cb, BTA_HF_CLIENT_SCO_CLOSE_E);
 658   }
 659 }