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           break;
 309
 310         case BTA_HF_CLIENT_SCO_OPEN_E:
 311           /* remove listening connection */
 312           bta_hf_client_sco_remove(client_cb);
 313
 314           /* create SCO connection to peer */
 315           bta_hf_client_sco_create(client_cb, true);
 316           client_cb->sco_state = BTA_HF_CLIENT_SCO_OPENING_ST;
 317           break;
 318
 319         case BTA_HF_CLIENT_SCO_SHUTDOWN_E:
 320         case BTA_HF_CLIENT_SCO_CLOSE_E:
 321           /* remove listening connection */
 322           bta_hf_client_sco_remove(client_cb);
 323
 324           client_cb->sco_state = BTA_HF_CLIENT_SCO_SHUTDOWN_ST;
 325           break;
 326
 327         case BTA_HF_CLIENT_SCO_CONN_CLOSE_E:
 328           /* SCO failed; create SCO listen connection */
 329           bta_hf_client_sco_create(client_cb, false);
 330           client_cb->sco_state = BTA_HF_CLIENT_SCO_LISTEN_ST;
 331           break;
 332
 333         default:
 334           APPL_TRACE_WARNING(
 335               "%s: BTA_HF_CLIENT_SCO_LISTEN_ST: Ignoring event %d", __func__,
 336               event);
 337           break;
 338       }
 339       break;
 340
 341     case BTA_HF_CLIENT_SCO_OPENING_ST:
 342       switch (event) {
 343         case BTA_HF_CLIENT_SCO_CLOSE_E:
 344           client_cb->sco_state = BTA_HF_CLIENT_SCO_OPEN_CL_ST;
 345           break;
 346
 347         case BTA_HF_CLIENT_SCO_SHUTDOWN_E:
 348           client_cb->sco_state = BTA_HF_CLIENT_SCO_SHUTTING_ST;
 349           break;
 350
 351         case BTA_HF_CLIENT_SCO_CONN_OPEN_E:
 352           client_cb->sco_state = BTA_HF_CLIENT_SCO_OPEN_ST;
 353           break;
 354
 355         case BTA_HF_CLIENT_SCO_CONN_CLOSE_E:
 356           /* SCO failed; create SCO listen connection */
 357           bta_hf_client_sco_create(client_cb, false);
 358           client_cb->sco_state = BTA_HF_CLIENT_SCO_LISTEN_ST;
 359           break;
 360
 361         default:
 362           APPL_TRACE_WARNING("BTA_HF_CLIENT_SCO_OPENING_ST: Ignoring event %d",
 363                              event);
 364           break;
 365       }
 366       break;
 367
 368     case BTA_HF_CLIENT_SCO_OPEN_CL_ST:
 369       switch (event) {
 370         case BTA_HF_CLIENT_SCO_OPEN_E:
 371           client_cb->sco_state = BTA_HF_CLIENT_SCO_OPENING_ST;
 372           break;
 373
 374         case BTA_HF_CLIENT_SCO_SHUTDOWN_E:
 375           client_cb->sco_state = BTA_HF_CLIENT_SCO_SHUTTING_ST;
 376           break;
 377
 378         case BTA_HF_CLIENT_SCO_CONN_OPEN_E:
 379           /* close SCO connection */
 380           bta_hf_client_sco_remove(client_cb);
 381
 382           client_cb->sco_state = BTA_HF_CLIENT_SCO_CLOSING_ST;
 383           break;
 384
 385         case BTA_HF_CLIENT_SCO_CONN_CLOSE_E:
 386           /* SCO failed; create SCO listen connection */
 387
 388           client_cb->sco_state = BTA_HF_CLIENT_SCO_LISTEN_ST;
 389           break;
 390
 391         default:
 392           APPL_TRACE_WARNING("BTA_HF_CLIENT_SCO_OPEN_CL_ST: Ignoring event %d",
 393                              event);
 394           break;
 395       }
 396       break;
 397
 398     case BTA_HF_CLIENT_SCO_OPEN_ST:
 399       switch (event) {
 400         case BTA_HF_CLIENT_SCO_CLOSE_E:
 401           if (bta_hf_client_sco_remove(client_cb)) {
 402             client_cb->sco_state = BTA_HF_CLIENT_SCO_CLOSING_ST;
 403           }
 404           break;
 405
 406         case BTA_HF_CLIENT_SCO_SHUTDOWN_E:
 407           /* remove listening connection */
 408           bta_hf_client_sco_remove(client_cb);
 409
 410           client_cb->sco_state = BTA_HF_CLIENT_SCO_SHUTTING_ST;
 411           break;
 412
 413         case BTA_HF_CLIENT_SCO_CONN_CLOSE_E:
 414           /* peer closed SCO */
 415           bta_hf_client_sco_create(client_cb, false);
 416           client_cb->sco_state = BTA_HF_CLIENT_SCO_LISTEN_ST;
 417           break;
 418
 419         default:
 420           APPL_TRACE_WARNING("BTA_HF_CLIENT_SCO_OPEN_ST: Ignoring event %d",
 421                              event);
 422           break;
 423       }
 424       break;
 425
 426     case BTA_HF_CLIENT_SCO_CLOSING_ST:
 427       switch (event) {
 428         case BTA_HF_CLIENT_SCO_OPEN_E:
 429           client_cb->sco_state = BTA_HF_CLIENT_SCO_CLOSE_OP_ST;
 430           break;
 431
 432         case BTA_HF_CLIENT_SCO_SHUTDOWN_E:
 433           client_cb->sco_state = BTA_HF_CLIENT_SCO_SHUTTING_ST;
 434           break;
 435
 436         case BTA_HF_CLIENT_SCO_CONN_CLOSE_E:
 437           /* peer closed sco; create SCO listen connection */
 438           bta_hf_client_sco_create(client_cb, false);
 439           client_cb->sco_state = BTA_HF_CLIENT_SCO_LISTEN_ST;
 440           break;
 441
 442         default:
 443           APPL_TRACE_WARNING("BTA_HF_CLIENT_SCO_CLOSING_ST: Ignoring event %d",
 444                              event);
 445           break;
 446       }
 447       break;
 448
 449     case BTA_HF_CLIENT_SCO_CLOSE_OP_ST:
 450       switch (event) {
 451         case BTA_HF_CLIENT_SCO_CLOSE_E:
 452           client_cb->sco_state = BTA_HF_CLIENT_SCO_CLOSING_ST;
 453           break;
 454
 455         case BTA_HF_CLIENT_SCO_SHUTDOWN_E:
 456           client_cb->sco_state = BTA_HF_CLIENT_SCO_SHUTTING_ST;
 457           break;
 458
 459         case BTA_HF_CLIENT_SCO_CONN_CLOSE_E:
 460           /* open SCO connection */
 461           bta_hf_client_sco_create(client_cb, true);
 462           client_cb->sco_state = BTA_HF_CLIENT_SCO_OPENING_ST;
 463           break;
 464
 465         default:
 466           APPL_TRACE_WARNING("BTA_HF_CLIENT_SCO_CLOSE_OP_ST: Ignoring event %d",
 467                              event);
 468           break;
 469       }
 470       break;
 471
 472     case BTA_HF_CLIENT_SCO_SHUTTING_ST:
 473       switch (event) {
 474         case BTA_HF_CLIENT_SCO_CONN_OPEN_E:
 475           /* close SCO connection; wait for conn close event */
 476           bta_hf_client_sco_remove(client_cb);
 477           break;
 478
 479         case BTA_HF_CLIENT_SCO_CONN_CLOSE_E:
 480           client_cb->sco_state = BTA_HF_CLIENT_SCO_SHUTDOWN_ST;
 481           break;
 482
 483         case BTA_HF_CLIENT_SCO_SHUTDOWN_E:
 484           client_cb->sco_state = BTA_HF_CLIENT_SCO_SHUTDOWN_ST;
 485           break;
 486
 487         default:
 488           APPL_TRACE_WARNING("BTA_HF_CLIENT_SCO_SHUTTING_ST: Ignoring event %d",
 489                              event);
 490           break;
 491       }
 492       break;
 493
 494     default:
 495       break;
 496   }
 497
 498   APPL_TRACE_DEBUG("%s: after state: %d", __func__, client_cb->sco_state);
 499 }
 500
 501 /*******************************************************************************
 502  *
 503  * Function         bta_hf_client_sco_listen
 504  *
 505  * Description      Initialize SCO listener
 506  *
 507  *
 508  * Returns          void
 509  *
 510  ******************************************************************************/
 511 void bta_hf_client_sco_listen(tBTA_HF_CLIENT_DATA* p_data) {
 512   APPL_TRACE_DEBUG("%s", __func__);
 513
 514   tBTA_HF_CLIENT_CB* client_cb =
 515       bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);
 516   if (client_cb == NULL) {
 517     APPL_TRACE_ERROR("%s: wrong handle to control block %d", __func__,
 518                      p_data->hdr.layer_specific);
 519     return;
 520   }
 521
 522   bta_hf_client_sco_event(client_cb, BTA_HF_CLIENT_SCO_LISTEN_E);
 523 }
 524
 525 /*******************************************************************************
 526  *
 527  * Function         bta_hf_client_sco_shutdown
 528  *
 529  * Description
 530  *
 531  *
 532  * Returns          void
 533  *
 534  ******************************************************************************/
 535 void bta_hf_client_sco_shutdown(tBTA_HF_CLIENT_CB* client_cb) {
 536   APPL_TRACE_DEBUG("%s", __func__);
 537
 538   bta_hf_client_sco_event(client_cb, BTA_HF_CLIENT_SCO_SHUTDOWN_E);
 539 }
 540
 541 /*******************************************************************************
 542  *
 543  * Function         bta_hf_client_sco_conn_open
 544  *
 545  * Description
 546  *
 547  *
 548  * Returns          void
 549  *
 550  ******************************************************************************/
 551 void bta_hf_client_sco_conn_open(tBTA_HF_CLIENT_DATA* p_data) {
 552   APPL_TRACE_DEBUG("%s", __func__);
 553
 554   tBTA_HF_CLIENT_CB* client_cb =
 555       bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);
 556   if (client_cb == NULL) {
 557     APPL_TRACE_ERROR("%s: wrong handle to control block %d", __func__,
 558                      p_data->hdr.layer_specific);
 559     return;
 560   }
 561
 562   bta_hf_client_sco_event(client_cb, BTA_HF_CLIENT_SCO_CONN_OPEN_E);
 563
 564   bta_sys_sco_open(BTA_ID_HS, 1, client_cb->peer_addr);
 565
 566   if (client_cb->negotiated_codec == BTM_SCO_CODEC_MSBC) {
 567     bta_hf_client_cback_sco(client_cb, BTA_HF_CLIENT_AUDIO_MSBC_OPEN_EVT);
 568   } else {
 569     bta_hf_client_cback_sco(client_cb, BTA_HF_CLIENT_AUDIO_OPEN_EVT);
 570   }
 571 }
 572
 573 /*******************************************************************************
 574  *
 575  * Function         bta_hf_client_sco_conn_close
 576  *
 577  * Description
 578  *
 579  *
 580  * Returns          void
 581  *
 582  ******************************************************************************/
 583 void bta_hf_client_sco_conn_close(tBTA_HF_CLIENT_DATA* p_data) {
 584   APPL_TRACE_DEBUG("%s", __func__);
 585
 586   tBTA_HF_CLIENT_CB* client_cb =
 587       bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);
 588   if (client_cb == NULL) {
 589     APPL_TRACE_ERROR("%s: wrong handle to control block %d", __func__,
 590                      p_data->hdr.layer_specific);
 591     return;
 592   }
 593
 594   /* clear current scb */
 595   client_cb->sco_idx = BTM_INVALID_SCO_INDEX;
 596
 597   bta_hf_client_sco_event(client_cb, BTA_HF_CLIENT_SCO_CONN_CLOSE_E);
 598
 599   bta_sys_sco_close(BTA_ID_HS, 1, client_cb->peer_addr);
 600
 601   bta_sys_sco_unuse(BTA_ID_HS, 1, client_cb->peer_addr);
 602
 603   /* call app callback */
 604   bta_hf_client_cback_sco(client_cb, BTA_HF_CLIENT_AUDIO_CLOSE_EVT);
 605
 606   if (client_cb->sco_close_rfc) {
 607     client_cb->sco_close_rfc = false;
 608     bta_hf_client_rfc_do_close(p_data);
 609   }
 610 }
 611
 612 /*******************************************************************************
 613  *
 614  * Function         bta_hf_client_sco_open
 615  *
 616  * Description
 617  *
 618  *
 619  * Returns          void
 620  *
 621  ******************************************************************************/
 622 void bta_hf_client_sco_open(tBTA_HF_CLIENT_DATA* p_data) {
 623   APPL_TRACE_DEBUG("%s", __func__);
 624
 625   tBTA_HF_CLIENT_CB* client_cb =
 626       bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);
 627   if (client_cb == NULL) {
 628     APPL_TRACE_ERROR("%s: wrong handle to control block %d", __func__,
 629                      p_data->hdr.layer_specific);
 630     return;
 631   }
 632
 633   bta_hf_client_sco_event(client_cb, BTA_HF_CLIENT_SCO_OPEN_E);
 634 }
 635
 636 /*******************************************************************************
 637  *
 638  * Function         bta_hf_client_sco_close
 639  *
 640  * Description
 641  *
 642  *
 643  * Returns          void
 644  *
 645  ******************************************************************************/
 646 void bta_hf_client_sco_close(tBTA_HF_CLIENT_DATA* p_data) {
 647   tBTA_HF_CLIENT_CB* client_cb =
 648       bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);
 649   if (client_cb == NULL) {
 650     APPL_TRACE_ERROR("%s: wrong handle to control block %d", __func__,
 651                      p_data->hdr.layer_specific);
 652     return;
 653   }
 654
 655   APPL_TRACE_DEBUG("%s: sco_idx 0x%x", __func__, client_cb->sco_idx);
 656
 657   if (client_cb->sco_idx != BTM_INVALID_SCO_INDEX) {
 658     bta_hf_client_sco_event(client_cb, BTA_HF_CLIENT_SCO_CLOSE_E);
 659   }
 660 }