hal/audio_extn/Hfp.cpp - LeafOS-Project/android_hardware_qcom_audio-ar - Gitiles

 /*
  * Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *   * Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *   * Redistributions in binary form must reproduce the above
  *     copyright notice, this list of conditions and the following
  *     disclaimer in the documentation and/or other materials provided
  *     with the distribution.
  *   * Neither the name of The Linux Foundation nor the names of its
  *     contributors may be used to endorse or promote products derived
  *     from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Changes from Qualcomm Innovation Center are provided under the following license:
  *
  * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
  * SPDX-License-Identifier: BSD-3-Clause-Clear
 */

 #define LOG_TAG "AHAL: hfp"
 #define LOG_NDDEBUG 0

 #include <errno.h>
 #include <math.h>
 #include "AudioCommon.h"
 #include <fcntl.h>
 #include <dirent.h>
 #include <sys/stat.h>
 #include <stdlib.h>
 #include <dlfcn.h>
 #include <math.h>
 #include <cutils/properties.h>
 #include "PalApi.h"
 #include "AudioDevice.h"

 #ifdef __cplusplus
 extern "C" {
 #endif

 #define AUDIO_PARAMETER_HFP_ENABLE      "hfp_enable"
 #define AUDIO_PARAMETER_HFP_SET_SAMPLING_RATE "hfp_set_sampling_rate"
 #define AUDIO_PARAMETER_KEY_HFP_VOLUME "hfp_volume"
 #define AUDIO_PARAMETER_HFP_PCM_DEV_ID "hfp_pcm_dev_id"

 #define AUDIO_PARAMETER_KEY_HFP_MIC_VOLUME "hfp_mic_volume"

 struct hfp_module {
     bool is_hfp_running;
     float hfp_volume;
     int ucid;
     float mic_volume;
     bool mic_mute;
     uint32_t sample_rate;
     pal_stream_handle_t *rx_stream_handle;
     pal_stream_handle_t *tx_stream_handle;
 };

 #define PLAYBACK_VOLUME_MAX 0x2000
 #define CAPTURE_VOLUME_DEFAULT                (15.0)
 static struct hfp_module hfpmod = {
     .is_hfp_running = 0,
     .hfp_volume = 0,
     .ucid = USECASE_AUDIO_HFP_SCO,
     .mic_volume = CAPTURE_VOLUME_DEFAULT,
     .mic_mute = 0,
     .sample_rate = 16000,
 };

 static int32_t hfp_set_volume(float value)
 {
     int32_t vol, ret = 0;
     struct pal_volume_data *pal_volume = NULL;

     AHAL_VERBOSE("entry");
     AHAL_DBG("(%f)\n", value);

     hfpmod.hfp_volume = value;

     if (value < 0.0) {
         AHAL_DBG("(%f) Under 0.0, assuming 0.0\n", value);
         value = 0.0;
     } else {
         value = ((value > 15.000000) ? 1.0 : (value / 15));
         AHAL_DBG("Volume brought with in range (%f)\n", value);
     }
     vol  = lrint((value * 0x2000) + 0.5);

     if (!hfpmod.is_hfp_running) {
         AHAL_VERBOSE("HFP not active, ignoring set_hfp_volume call");
         return -EIO;
     }

     AHAL_DBG("Setting HFP volume to %d \n", vol);

     pal_volume = (struct pal_volume_data *)malloc(sizeof(struct pal_volume_data)
             +sizeof(struct pal_channel_vol_kv));

     if (!pal_volume)
        return -ENOMEM;

     pal_volume->no_of_volpair = 1;
     pal_volume->volume_pair[0].channel_mask = 0x03;
     pal_volume->volume_pair[0].vol = value;
     ret = pal_stream_set_volume(hfpmod.rx_stream_handle, pal_volume);
     if (ret)
         AHAL_ERR("set volume failed: %d \n", ret);

     free(pal_volume);
     AHAL_VERBOSE("exit");
     return ret;
 }

 /*Set mic volume to value.
  * *
  * * This interface is used for mic volume control, set mic volume as value(range 0 ~ 15).
  * */
 static int hfp_set_mic_volume(float value)
 {
     int volume, ret = 0;
     struct pal_volume_data *pal_volume = NULL;

     AHAL_DBG("enter, value=%f", value);

     if (!hfpmod.is_hfp_running) {
         AHAL_ERR("HFP not active, ignoring set_hfp_mic_volume call");
         return -EIO;
     }

     if (value < 0.0) {
         AHAL_DBG("(%f) Under 0.0, assuming 0.0\n", value);
         value = 0.0;
     } else if (value > CAPTURE_VOLUME_DEFAULT) {
         value = CAPTURE_VOLUME_DEFAULT;
         AHAL_DBG("Volume brought within range (%f)\n", value);
     }

     value = value / CAPTURE_VOLUME_DEFAULT;

     volume = (int)(value * PLAYBACK_VOLUME_MAX);

     pal_volume = (struct pal_volume_data *)malloc(sizeof(struct pal_volume_data)
             +sizeof(struct pal_channel_vol_kv));
     if (!pal_volume) {
         AHAL_ERR("Failed to allocate memory for pal_volume");
         return -ENOMEM;
     }
     pal_volume->no_of_volpair = 1;
     pal_volume->volume_pair[0].channel_mask = 0x03;
     pal_volume->volume_pair[0].vol = value;
     if (pal_stream_set_volume(hfpmod.tx_stream_handle, pal_volume) < 0) {
         AHAL_ERR("Couldn't set HFP Volume: [%d]", volume);
         free(pal_volume);
         pal_volume = NULL;
         return -EINVAL;
     }

     free(pal_volume);
     pal_volume = NULL;

     return ret;
 }

 static float hfp_get_mic_volume(void)
 {
     return hfpmod.mic_volume;
 }

 static int32_t start_hfp(std::shared_ptr<AudioDevice> adev __unused,
         struct str_parms *parms __unused)
 {
     int32_t ret = 0;
     uint32_t no_of_devices = 2;
     struct pal_stream_attributes stream_attr = {};
     struct pal_stream_attributes stream_tx_attr = {};
     struct pal_device devices[2] = {};
     struct pal_channel_info ch_info;

     AHAL_DBG("HFP start enter");
     if (hfpmod.rx_stream_handle || hfpmod.tx_stream_handle)
         return 0; //hfp already running;

     pal_param_device_connection_t param_device_connection;

     param_device_connection.id = PAL_DEVICE_IN_BLUETOOTH_SCO_HEADSET;
     param_device_connection.connection_state = true;
     ret =  pal_set_param(PAL_PARAM_ID_DEVICE_CONNECTION,
                         (void*)&param_device_connection,
                         sizeof(pal_param_device_connection_t));
     if (ret != 0) {
         AHAL_ERR("Set PAL_PARAM_ID_DEVICE_CONNECTION for %d failed", param_device_connection.id);
         return ret;
     }

     param_device_connection.id = PAL_DEVICE_OUT_BLUETOOTH_SCO;
     param_device_connection.connection_state = true;
     ret =  pal_set_param(PAL_PARAM_ID_DEVICE_CONNECTION,
                         (void*)&param_device_connection,
                         sizeof(pal_param_device_connection_t));
     if (ret != 0) {
         AHAL_ERR("Set PAL_PARAM_ID_DEVICE_CONNECTION for %d failed", param_device_connection.id);
         return ret;
     }

     pal_param_btsco_t param_btsco;

     param_btsco.is_bt_hfp = true;
     param_btsco.bt_sco_on = true;
     ret =  pal_set_param(PAL_PARAM_ID_BT_SCO,
                         (void*)&param_btsco,
                         sizeof(pal_param_btsco_t));
     if (ret != 0) {
         AHAL_ERR("Set PAL_PARAM_ID_BT_SCO failed");
         return ret;
     }

     if (hfpmod.sample_rate == 16000) {
         param_btsco.bt_wb_speech_enabled = true;
     }
     else
     {
         param_btsco.bt_wb_speech_enabled = false;
     }

     ret =  pal_set_param(PAL_PARAM_ID_BT_SCO_WB,
                         (void*)&param_btsco,
                         sizeof(pal_param_btsco_t));
     if (ret != 0) {
         AHAL_ERR("Set PAL_PARAM_ID_BT_SCO_WB failed");
         return ret;
     }

     ch_info.channels = 1;
     ch_info.ch_map[0] = PAL_CHMAP_CHANNEL_FL;

     /* BT SCO -> Spkr */
     stream_attr.type = PAL_STREAM_LOOPBACK;
     stream_attr.info.opt_stream_info.loopback_type = PAL_STREAM_LOOPBACK_HFP_RX;
     stream_attr.direction = PAL_AUDIO_INPUT_OUTPUT;
     stream_attr.in_media_config.sample_rate = hfpmod.sample_rate;
     stream_attr.in_media_config.bit_width = 16;
     stream_attr.in_media_config.ch_info = ch_info;
     stream_attr.in_media_config.aud_fmt_id = PAL_AUDIO_FMT_PCM_S16_LE;

     stream_attr.out_media_config.sample_rate = 48000;
     stream_attr.out_media_config.bit_width = 16;
     stream_attr.out_media_config.ch_info = ch_info;
     stream_attr.out_media_config.aud_fmt_id = PAL_AUDIO_FMT_PCM_S16_LE;

     devices[0].id = PAL_DEVICE_IN_BLUETOOTH_SCO_HEADSET;
     devices[0].config.sample_rate = hfpmod.sample_rate;
     devices[0].config.bit_width = 16;
     devices[0].config.ch_info = ch_info;
     devices[0].config.aud_fmt_id = PAL_AUDIO_FMT_PCM_S16_LE;

     devices[1].id = PAL_DEVICE_OUT_SPEAKER;

     ret = pal_stream_open(&stream_attr,
             no_of_devices, devices,
             0,
             NULL,
             NULL,
             0,
             &hfpmod.rx_stream_handle);
     if (ret != 0) {
         AHAL_ERR("HFP rx stream (BT SCO->Spkr) open failed, rc %d", ret);
         return ret;
     }
     ret = pal_stream_start(hfpmod.rx_stream_handle);
     if (ret != 0) {
         AHAL_ERR("HFP rx stream (BT SCO->Spkr) start failed, rc %d", ret);
         pal_stream_close(hfpmod.rx_stream_handle);
         return ret;
     }

     /* Mic -> BT SCO */
     stream_tx_attr.type = PAL_STREAM_LOOPBACK;
     stream_tx_attr.info.opt_stream_info.loopback_type = PAL_STREAM_LOOPBACK_HFP_TX;
     stream_tx_attr.direction = PAL_AUDIO_INPUT_OUTPUT;
     stream_tx_attr.in_media_config.sample_rate = hfpmod.sample_rate;
     stream_tx_attr.in_media_config.bit_width = 16;
     stream_tx_attr.in_media_config.ch_info = ch_info;
     stream_tx_attr.in_media_config.aud_fmt_id = PAL_AUDIO_FMT_PCM_S16_LE;

     stream_tx_attr.out_media_config.sample_rate = 48000;
     stream_tx_attr.out_media_config.bit_width = 16;
     stream_tx_attr.out_media_config.ch_info = ch_info;
     stream_tx_attr.out_media_config.aud_fmt_id = PAL_AUDIO_FMT_PCM_S16_LE;

     devices[0].id = PAL_DEVICE_OUT_BLUETOOTH_SCO;
     devices[0].config.sample_rate = hfpmod.sample_rate;
     devices[0].config.bit_width = 16;
     devices[0].config.ch_info = ch_info;
     devices[0].config.aud_fmt_id = PAL_AUDIO_FMT_PCM_S16_LE;

     devices[1].id = PAL_DEVICE_IN_SPEAKER_MIC;

     ret = pal_stream_open(&stream_tx_attr,
             no_of_devices, devices,
             0,
             NULL,
             NULL,
             0,
             &hfpmod.tx_stream_handle);
     if (ret != 0) {
         AHAL_ERR("HFP tx stream (Mic->BT SCO) open failed, rc %d", ret);
         pal_stream_stop(hfpmod.rx_stream_handle);
         pal_stream_close(hfpmod.rx_stream_handle);
         hfpmod.rx_stream_handle = NULL;
         return ret;
     }
     ret = pal_stream_start(hfpmod.tx_stream_handle);
     if (ret != 0) {
         AHAL_ERR("HFP tx stream (Mic->BT SCO) start failed, rc %d", ret);
         pal_stream_close(hfpmod.tx_stream_handle);
         pal_stream_stop(hfpmod.rx_stream_handle);
         pal_stream_close(hfpmod.rx_stream_handle);
         hfpmod.rx_stream_handle = NULL;
         hfpmod.tx_stream_handle = NULL;
         return ret;
     }
     hfpmod.mic_mute = false;
     hfpmod.is_hfp_running = true;
     hfp_set_volume(hfpmod.hfp_volume);

     AHAL_DBG("HFP start end");
     return ret;
 }

 static int32_t stop_hfp()
 {
     int32_t ret = 0;

     AHAL_DBG("HFP stop enter");
     hfpmod.is_hfp_running = false;
     if (hfpmod.rx_stream_handle) {
         pal_stream_stop(hfpmod.rx_stream_handle);
         pal_stream_close(hfpmod.rx_stream_handle);
         hfpmod.rx_stream_handle = NULL;
     }
     if (hfpmod.tx_stream_handle) {
         pal_stream_stop(hfpmod.tx_stream_handle);
         pal_stream_close(hfpmod.tx_stream_handle);
         hfpmod.tx_stream_handle = NULL;
     }

     pal_param_btsco_t param_btsco;

     param_btsco.is_bt_hfp = true;
     param_btsco.bt_sco_on = true;
     ret =  pal_set_param(PAL_PARAM_ID_BT_SCO,
                         (void*)&param_btsco,
                         sizeof(pal_param_btsco_t));
     if (ret != 0) {
         AHAL_ERR("Set PAL_PARAM_ID_BT_SCO failed");
     }

     pal_param_device_connection_t param_device_connection;

     param_device_connection.id = PAL_DEVICE_IN_BLUETOOTH_SCO_HEADSET;
     param_device_connection.connection_state = false;
     ret =  pal_set_param(PAL_PARAM_ID_DEVICE_CONNECTION,
                         (void*)&param_device_connection,
                         sizeof(pal_param_device_connection_t));
     if (ret != 0) {
         AHAL_ERR("Set PAL_PARAM_ID_DEVICE_DISCONNECTION for %d failed", param_device_connection.id);
     }

     param_device_connection.id = PAL_DEVICE_OUT_BLUETOOTH_SCO;
     param_device_connection.connection_state = false;
     ret =  pal_set_param(PAL_PARAM_ID_DEVICE_CONNECTION,
                         (void*)&param_device_connection,
                         sizeof(pal_param_device_connection_t));
     if (ret != 0) {
         AHAL_ERR("Set PAL_PARAM_ID_DEVICE_DISCONNECTION for %d failed", param_device_connection.id);
     }

     AHAL_DBG("HFP stop end");
     return ret;
 }

 void hfp_init()
 {
     return;
 }

 bool hfp_is_active(std::shared_ptr<AudioDevice> adev __unused)
 {
     return hfpmod.is_hfp_running;
 }

 audio_usecase_t hfp_get_usecase()
 {
     return hfpmod.ucid;
 }

 /*Set mic mute state.
  * *
  * * This interface is used for mic mute state control
  * */
 int hfp_set_mic_mute(bool state)
 {
     int rc = 0;

     if (state == hfpmod.mic_mute) {
         AHAL_DBG("mute state already %d", state);
         return rc;
     }
     rc = hfp_set_mic_volume((state == true) ? 0.0 : hfpmod.mic_volume);
     if (rc == 0)
         hfpmod.mic_mute = state;
     AHAL_DBG("Setting mute state %d, rc %d\n", state, rc);
     return rc;
 }

 int hfp_set_mic_mute2(std::shared_ptr<AudioDevice> adev __unused, bool state __unused)
 {
     AHAL_DBG("Unsupported\n");
     return 0;
 }

 void hfp_set_parameters(std::shared_ptr<AudioDevice> adev, struct str_parms *parms)
 {
     int status = 0;
     char value[32]={0};
     float vol;
     int val;
     int rate;

     AHAL_DBG("enter");

     status = str_parms_get_str(parms, AUDIO_PARAMETER_HFP_ENABLE, value,
                                     sizeof(value));
     if (status >= 0) {
         if (!strncmp(value, "true", sizeof(value)) && !hfpmod.is_hfp_running) {
             status = start_hfp(adev, parms);
             /*
              * Sync to adev mic mute state if hfpmod.mic_mute state is lost due
              * to HFP session tear down during device switch on companion device.
              */
             if (hfpmod.mic_mute != adev->mute_) {
                 AHAL_DBG("update mic mute with latest mute state = %d", adev->mute_);
                 hfp_set_mic_mute(adev->mute_);
             }
         } else if (!strncmp(value, "false", sizeof(value)) && hfpmod.is_hfp_running) {
             stop_hfp();
         } else {
             AHAL_ERR("hfp_enable=%s is unsupported", value);
         }
     }

     memset(value, 0, sizeof(value));
     status = str_parms_get_str(parms,AUDIO_PARAMETER_HFP_SET_SAMPLING_RATE, value,
                                     sizeof(value));
     if (status >= 0) {
         rate = atoi(value);
         if (rate == 8000){
             hfpmod.ucid = USECASE_AUDIO_HFP_SCO;
             hfpmod.sample_rate = (uint32_t) rate;
         } else if (rate == 16000){
             hfpmod.ucid = USECASE_AUDIO_HFP_SCO_WB;
             hfpmod.sample_rate = (uint32_t) rate;
         } else
             AHAL_ERR("Unsupported rate.. %d", rate);
     }

     memset(value, 0, sizeof(value));
     status = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_HFP_VOLUME,
                                     value, sizeof(value));
     if (status >= 0) {
         if (sscanf(value, "%f", &vol) != 1){
             AHAL_ERR("error in retrieving hfp volume");
             status = -EIO;
             goto exit;
         }
         AHAL_DBG("set_hfp_volume usecase, Vol: [%f]", vol);
         hfp_set_volume(vol);
     }

     memset(value, 0, sizeof(value));
     status = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_HFP_MIC_VOLUME,
                                     value, sizeof(value));
     if (status >= 0) {
         if (sscanf(value, "%f", &vol) != 1){
             AHAL_ERR("error in retrieving hfp mic volume");
             status = -EIO;
             goto exit;
         }
         AHAL_DBG("set_hfp_mic_volume usecase, Vol: [%f]", vol);
         if (hfp_set_mic_volume(vol) == 0)
             hfpmod.mic_volume = vol;
     }

 exit:
     AHAL_VERBOSE("Exit");
 }

 #ifdef __cplusplus
 }
 #endif
	/*
	* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met:
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following
	* disclaimer in the documentation and/or other materials provided
	* with the distribution.
	* * Neither the name of The Linux Foundation nor the names of its
	* contributors may be used to endorse or promote products derived
	* from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
	* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*
	* Changes from Qualcomm Innovation Center are provided under the following license:
	*
	* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
	* SPDX-License-Identifier: BSD-3-Clause-Clear
	*/

	#define LOG_TAG "AHAL: hfp"
	#define LOG_NDDEBUG 0

	#include <errno.h>
	#include <math.h>
	#include "AudioCommon.h"
	#include <fcntl.h>
	#include <dirent.h>
	#include <sys/stat.h>
	#include <stdlib.h>
	#include <dlfcn.h>
	#include <math.h>
	#include <cutils/properties.h>
	#include "PalApi.h"
	#include "AudioDevice.h"

	#ifdef __cplusplus
	extern "C" {
	#endif

	#define AUDIO_PARAMETER_HFP_ENABLE "hfp_enable"
	#define AUDIO_PARAMETER_HFP_SET_SAMPLING_RATE "hfp_set_sampling_rate"
	#define AUDIO_PARAMETER_KEY_HFP_VOLUME "hfp_volume"
	#define AUDIO_PARAMETER_HFP_PCM_DEV_ID "hfp_pcm_dev_id"

	#define AUDIO_PARAMETER_KEY_HFP_MIC_VOLUME "hfp_mic_volume"

	struct hfp_module {
	bool is_hfp_running;
	float hfp_volume;
	int ucid;
	float mic_volume;
	bool mic_mute;
	uint32_t sample_rate;
	pal_stream_handle_t *rx_stream_handle;
	pal_stream_handle_t *tx_stream_handle;
	};

	#define PLAYBACK_VOLUME_MAX 0x2000
	#define CAPTURE_VOLUME_DEFAULT (15.0)
	static struct hfp_module hfpmod = {
	.is_hfp_running = 0,
	.hfp_volume = 0,
	.ucid = USECASE_AUDIO_HFP_SCO,
	.mic_volume = CAPTURE_VOLUME_DEFAULT,
	.mic_mute = 0,
	.sample_rate = 16000,
	};

	static int32_t hfp_set_volume(float value)
	{
	int32_t vol, ret = 0;
	struct pal_volume_data *pal_volume = NULL;

	AHAL_VERBOSE("entry");
	AHAL_DBG("(%f)\n", value);

	hfpmod.hfp_volume = value;

	if (value < 0.0) {
	AHAL_DBG("(%f) Under 0.0, assuming 0.0\n", value);
	value = 0.0;
	} else {
	value = ((value > 15.000000) ? 1.0 : (value / 15));
	AHAL_DBG("Volume brought with in range (%f)\n", value);
	}
	vol = lrint((value * 0x2000) + 0.5);

	if (!hfpmod.is_hfp_running) {
	AHAL_VERBOSE("HFP not active, ignoring set_hfp_volume call");
	return -EIO;
	}

	AHAL_DBG("Setting HFP volume to %d \n", vol);

	pal_volume = (struct pal_volume_data *)malloc(sizeof(struct pal_volume_data)
	+sizeof(struct pal_channel_vol_kv));

	if (!pal_volume)
	return -ENOMEM;

	pal_volume->no_of_volpair = 1;
	pal_volume->volume_pair[0].channel_mask = 0x03;
	pal_volume->volume_pair[0].vol = value;
	ret = pal_stream_set_volume(hfpmod.rx_stream_handle, pal_volume);
	if (ret)
	AHAL_ERR("set volume failed: %d \n", ret);

	free(pal_volume);
	AHAL_VERBOSE("exit");
	return ret;
	}

	/*Set mic volume to value.
	* *
	* * This interface is used for mic volume control, set mic volume as value(range 0 ~ 15).
	* */
	static int hfp_set_mic_volume(float value)
	{
	int volume, ret = 0;
	struct pal_volume_data *pal_volume = NULL;

	AHAL_DBG("enter, value=%f", value);

	if (!hfpmod.is_hfp_running) {
	AHAL_ERR("HFP not active, ignoring set_hfp_mic_volume call");
	return -EIO;
	}

	if (value < 0.0) {
	AHAL_DBG("(%f) Under 0.0, assuming 0.0\n", value);
	value = 0.0;
	} else if (value > CAPTURE_VOLUME_DEFAULT) {
	value = CAPTURE_VOLUME_DEFAULT;
	AHAL_DBG("Volume brought within range (%f)\n", value);
	}

	value = value / CAPTURE_VOLUME_DEFAULT;

	volume = (int)(value * PLAYBACK_VOLUME_MAX);

	pal_volume = (struct pal_volume_data *)malloc(sizeof(struct pal_volume_data)
	+sizeof(struct pal_channel_vol_kv));
	if (!pal_volume) {
	AHAL_ERR("Failed to allocate memory for pal_volume");
	return -ENOMEM;
	}
	pal_volume->no_of_volpair = 1;
	pal_volume->volume_pair[0].channel_mask = 0x03;
	pal_volume->volume_pair[0].vol = value;
	if (pal_stream_set_volume(hfpmod.tx_stream_handle, pal_volume) < 0) {
	AHAL_ERR("Couldn't set HFP Volume: [%d]", volume);
	free(pal_volume);
	pal_volume = NULL;
	return -EINVAL;
	}

	free(pal_volume);
	pal_volume = NULL;

	return ret;
	}

	static float hfp_get_mic_volume(void)
	{
	return hfpmod.mic_volume;
	}

	static int32_t start_hfp(std::shared_ptr<AudioDevice> adev __unused,
	struct str_parms *parms __unused)
	{
	int32_t ret = 0;
	uint32_t no_of_devices = 2;
	struct pal_stream_attributes stream_attr = {};
	struct pal_stream_attributes stream_tx_attr = {};
	struct pal_device devices[2] = {};
	struct pal_channel_info ch_info;

	AHAL_DBG("HFP start enter");
	if (hfpmod.rx_stream_handle \|\| hfpmod.tx_stream_handle)
	return 0; //hfp already running;

	pal_param_device_connection_t param_device_connection;

	param_device_connection.id = PAL_DEVICE_IN_BLUETOOTH_SCO_HEADSET;
	param_device_connection.connection_state = true;
	ret = pal_set_param(PAL_PARAM_ID_DEVICE_CONNECTION,
	(void*)&param_device_connection,
	sizeof(pal_param_device_connection_t));
	if (ret != 0) {
	AHAL_ERR("Set PAL_PARAM_ID_DEVICE_CONNECTION for %d failed", param_device_connection.id);
	return ret;
	}

	param_device_connection.id = PAL_DEVICE_OUT_BLUETOOTH_SCO;
	param_device_connection.connection_state = true;
	ret = pal_set_param(PAL_PARAM_ID_DEVICE_CONNECTION,
	(void*)&param_device_connection,
	sizeof(pal_param_device_connection_t));
	if (ret != 0) {
	AHAL_ERR("Set PAL_PARAM_ID_DEVICE_CONNECTION for %d failed", param_device_connection.id);
	return ret;
	}

	pal_param_btsco_t param_btsco;

	param_btsco.is_bt_hfp = true;
	param_btsco.bt_sco_on = true;
	ret = pal_set_param(PAL_PARAM_ID_BT_SCO,
	(void*)&param_btsco,
	sizeof(pal_param_btsco_t));
	if (ret != 0) {
	AHAL_ERR("Set PAL_PARAM_ID_BT_SCO failed");
	return ret;
	}

	if (hfpmod.sample_rate == 16000) {
	param_btsco.bt_wb_speech_enabled = true;
	}
	else
	{
	param_btsco.bt_wb_speech_enabled = false;
	}

	ret = pal_set_param(PAL_PARAM_ID_BT_SCO_WB,
	(void*)&param_btsco,
	sizeof(pal_param_btsco_t));
	if (ret != 0) {
	AHAL_ERR("Set PAL_PARAM_ID_BT_SCO_WB failed");
	return ret;
	}

	ch_info.channels = 1;
	ch_info.ch_map[0] = PAL_CHMAP_CHANNEL_FL;

	/* BT SCO -> Spkr */
	stream_attr.type = PAL_STREAM_LOOPBACK;
	stream_attr.info.opt_stream_info.loopback_type = PAL_STREAM_LOOPBACK_HFP_RX;
	stream_attr.direction = PAL_AUDIO_INPUT_OUTPUT;
	stream_attr.in_media_config.sample_rate = hfpmod.sample_rate;
	stream_attr.in_media_config.bit_width = 16;
	stream_attr.in_media_config.ch_info = ch_info;
	stream_attr.in_media_config.aud_fmt_id = PAL_AUDIO_FMT_PCM_S16_LE;

	stream_attr.out_media_config.sample_rate = 48000;
	stream_attr.out_media_config.bit_width = 16;
	stream_attr.out_media_config.ch_info = ch_info;
	stream_attr.out_media_config.aud_fmt_id = PAL_AUDIO_FMT_PCM_S16_LE;

	devices[0].id = PAL_DEVICE_IN_BLUETOOTH_SCO_HEADSET;
	devices[0].config.sample_rate = hfpmod.sample_rate;
	devices[0].config.bit_width = 16;
	devices[0].config.ch_info = ch_info;
	devices[0].config.aud_fmt_id = PAL_AUDIO_FMT_PCM_S16_LE;

	devices[1].id = PAL_DEVICE_OUT_SPEAKER;

	ret = pal_stream_open(&stream_attr,
	no_of_devices, devices,
	0,
	NULL,
	NULL,
	0,
	&hfpmod.rx_stream_handle);
	if (ret != 0) {
	AHAL_ERR("HFP rx stream (BT SCO->Spkr) open failed, rc %d", ret);
	return ret;
	}
	ret = pal_stream_start(hfpmod.rx_stream_handle);
	if (ret != 0) {
	AHAL_ERR("HFP rx stream (BT SCO->Spkr) start failed, rc %d", ret);
	pal_stream_close(hfpmod.rx_stream_handle);
	return ret;
	}

	/* Mic -> BT SCO */
	stream_tx_attr.type = PAL_STREAM_LOOPBACK;
	stream_tx_attr.info.opt_stream_info.loopback_type = PAL_STREAM_LOOPBACK_HFP_TX;
	stream_tx_attr.direction = PAL_AUDIO_INPUT_OUTPUT;
	stream_tx_attr.in_media_config.sample_rate = hfpmod.sample_rate;
	stream_tx_attr.in_media_config.bit_width = 16;
	stream_tx_attr.in_media_config.ch_info = ch_info;
	stream_tx_attr.in_media_config.aud_fmt_id = PAL_AUDIO_FMT_PCM_S16_LE;

	stream_tx_attr.out_media_config.sample_rate = 48000;
	stream_tx_attr.out_media_config.bit_width = 16;
	stream_tx_attr.out_media_config.ch_info = ch_info;
	stream_tx_attr.out_media_config.aud_fmt_id = PAL_AUDIO_FMT_PCM_S16_LE;

	devices[0].id = PAL_DEVICE_OUT_BLUETOOTH_SCO;
	devices[0].config.sample_rate = hfpmod.sample_rate;
	devices[0].config.bit_width = 16;
	devices[0].config.ch_info = ch_info;
	devices[0].config.aud_fmt_id = PAL_AUDIO_FMT_PCM_S16_LE;

	devices[1].id = PAL_DEVICE_IN_SPEAKER_MIC;

	ret = pal_stream_open(&stream_tx_attr,
	no_of_devices, devices,
	0,
	NULL,
	NULL,
	0,
	&hfpmod.tx_stream_handle);
	if (ret != 0) {
	AHAL_ERR("HFP tx stream (Mic->BT SCO) open failed, rc %d", ret);
	pal_stream_stop(hfpmod.rx_stream_handle);
	pal_stream_close(hfpmod.rx_stream_handle);
	hfpmod.rx_stream_handle = NULL;
	return ret;
	}
	ret = pal_stream_start(hfpmod.tx_stream_handle);
	if (ret != 0) {
	AHAL_ERR("HFP tx stream (Mic->BT SCO) start failed, rc %d", ret);
	pal_stream_close(hfpmod.tx_stream_handle);
	pal_stream_stop(hfpmod.rx_stream_handle);
	pal_stream_close(hfpmod.rx_stream_handle);
	hfpmod.rx_stream_handle = NULL;
	hfpmod.tx_stream_handle = NULL;
	return ret;
	}
	hfpmod.mic_mute = false;
	hfpmod.is_hfp_running = true;
	hfp_set_volume(hfpmod.hfp_volume);

	AHAL_DBG("HFP start end");
	return ret;
	}

	static int32_t stop_hfp()
	{
	int32_t ret = 0;

	AHAL_DBG("HFP stop enter");
	hfpmod.is_hfp_running = false;
	if (hfpmod.rx_stream_handle) {
	pal_stream_stop(hfpmod.rx_stream_handle);
	pal_stream_close(hfpmod.rx_stream_handle);
	hfpmod.rx_stream_handle = NULL;
	}
	if (hfpmod.tx_stream_handle) {
	pal_stream_stop(hfpmod.tx_stream_handle);
	pal_stream_close(hfpmod.tx_stream_handle);
	hfpmod.tx_stream_handle = NULL;
	}

	pal_param_btsco_t param_btsco;

	param_btsco.is_bt_hfp = true;
	param_btsco.bt_sco_on = true;
	ret = pal_set_param(PAL_PARAM_ID_BT_SCO,
	(void*)&param_btsco,
	sizeof(pal_param_btsco_t));
	if (ret != 0) {
	AHAL_ERR("Set PAL_PARAM_ID_BT_SCO failed");
	}

	pal_param_device_connection_t param_device_connection;

	param_device_connection.id = PAL_DEVICE_IN_BLUETOOTH_SCO_HEADSET;
	param_device_connection.connection_state = false;
	ret = pal_set_param(PAL_PARAM_ID_DEVICE_CONNECTION,
	(void*)&param_device_connection,
	sizeof(pal_param_device_connection_t));
	if (ret != 0) {
	AHAL_ERR("Set PAL_PARAM_ID_DEVICE_DISCONNECTION for %d failed", param_device_connection.id);
	}

	param_device_connection.id = PAL_DEVICE_OUT_BLUETOOTH_SCO;
	param_device_connection.connection_state = false;
	ret = pal_set_param(PAL_PARAM_ID_DEVICE_CONNECTION,
	(void*)&param_device_connection,
	sizeof(pal_param_device_connection_t));
	if (ret != 0) {
	AHAL_ERR("Set PAL_PARAM_ID_DEVICE_DISCONNECTION for %d failed", param_device_connection.id);
	}

	AHAL_DBG("HFP stop end");
	return ret;
	}

	void hfp_init()
	{
	return;
	}

	bool hfp_is_active(std::shared_ptr<AudioDevice> adev __unused)
	{
	return hfpmod.is_hfp_running;
	}

	audio_usecase_t hfp_get_usecase()
	{
	return hfpmod.ucid;
	}

	/*Set mic mute state.
	* *
	* * This interface is used for mic mute state control
	* */
	int hfp_set_mic_mute(bool state)
	{
	int rc = 0;

	if (state == hfpmod.mic_mute) {
	AHAL_DBG("mute state already %d", state);
	return rc;
	}
	rc = hfp_set_mic_volume((state == true) ? 0.0 : hfpmod.mic_volume);
	if (rc == 0)
	hfpmod.mic_mute = state;
	AHAL_DBG("Setting mute state %d, rc %d\n", state, rc);
	return rc;
	}

	int hfp_set_mic_mute2(std::shared_ptr<AudioDevice> adev __unused, bool state __unused)
	{
	AHAL_DBG("Unsupported\n");
	return 0;
	}

	void hfp_set_parameters(std::shared_ptr<AudioDevice> adev, struct str_parms *parms)
	{
	int status = 0;
	char value[32]={0};
	float vol;
	int val;
	int rate;

	AHAL_DBG("enter");

	status = str_parms_get_str(parms, AUDIO_PARAMETER_HFP_ENABLE, value,
	sizeof(value));
	if (status >= 0) {
	if (!strncmp(value, "true", sizeof(value)) && !hfpmod.is_hfp_running) {
	status = start_hfp(adev, parms);
	/*
	* Sync to adev mic mute state if hfpmod.mic_mute state is lost due
	* to HFP session tear down during device switch on companion device.
	*/
	if (hfpmod.mic_mute != adev->mute_) {
	AHAL_DBG("update mic mute with latest mute state = %d", adev->mute_);
	hfp_set_mic_mute(adev->mute_);
	}
	} else if (!strncmp(value, "false", sizeof(value)) && hfpmod.is_hfp_running) {
	stop_hfp();
	} else {
	AHAL_ERR("hfp_enable=%s is unsupported", value);
	}
	}

	memset(value, 0, sizeof(value));
	status = str_parms_get_str(parms,AUDIO_PARAMETER_HFP_SET_SAMPLING_RATE, value,
	sizeof(value));
	if (status >= 0) {
	rate = atoi(value);
	if (rate == 8000){
	hfpmod.ucid = USECASE_AUDIO_HFP_SCO;
	hfpmod.sample_rate = (uint32_t) rate;
	} else if (rate == 16000){
	hfpmod.ucid = USECASE_AUDIO_HFP_SCO_WB;
	hfpmod.sample_rate = (uint32_t) rate;
	} else
	AHAL_ERR("Unsupported rate.. %d", rate);
	}

	memset(value, 0, sizeof(value));
	status = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_HFP_VOLUME,
	value, sizeof(value));
	if (status >= 0) {
	if (sscanf(value, "%f", &vol) != 1){
	AHAL_ERR("error in retrieving hfp volume");
	status = -EIO;
	goto exit;
	}
	AHAL_DBG("set_hfp_volume usecase, Vol: [%f]", vol);
	hfp_set_volume(vol);
	}

	memset(value, 0, sizeof(value));
	status = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_HFP_MIC_VOLUME,
	value, sizeof(value));
	if (status >= 0) {
	if (sscanf(value, "%f", &vol) != 1){
	AHAL_ERR("error in retrieving hfp mic volume");
	status = -EIO;
	goto exit;
	}
	AHAL_DBG("set_hfp_mic_volume usecase, Vol: [%f]", vol);
	if (hfp_set_mic_volume(vol) == 0)
	hfpmod.mic_volume = vol;
	}

	exit:
	AHAL_VERBOSE("Exit");
	}

	#ifdef __cplusplus
	}
	#endif