blob: 4eb6d711ece8cc954e20142f88a0f40f5f2a2e1d [file] [log] [blame]
/*
** Copyright 2008, The Android Open-Source Project
** Copyright (c) 2010-2012, Code Aurora Forum. All rights reserved.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
#include <math.h>
//#define LOG_NDEBUG 0
#define LOG_TAG "AudioHardwareMSM8660"
#include <utils/Log.h>
#include <utils/String8.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dlfcn.h>
#include <fcntl.h>
#include "AudioHardware.h"
#include <media/AudioSystem.h>
#include <cutils/properties.h>
#include <linux/android_pmem.h>
#ifdef QCOM_ACDB_ENABLED
#include <linux/msm_audio_acdb.h>
#endif
#include <linux/msm_audio_mvs.h>
#include <sys/mman.h>
#include "control.h"
#include "acdb.h"
#ifdef HTC_ACOUSTIC_AUDIO
extern "C" {
#include <linux/spi_aic3254.h>
#include <linux/tpa2051d3.h>
}
#define DSP_EFFECT_KEY "dolby_srs_eq"
#endif
#define VOICE_SESSION_NAME "Voice session"
#define VOIP_SESSION_NAME "VoIP session"
// hardware specific functions
#define LOG_SND_RPC 0 // Set to 1 to log sound RPC's
#define DUALMIC_KEY "dualmic_enabled"
#define BTHEADSET_VGS "bt_headset_vgs"
#define ANC_KEY "anc_enabled"
#define TTY_MODE_KEY "tty_mode"
#define ECHO_SUPRESSION "ec_supported"
#define MVS_DEVICE "/dev/msm_mvs"
#ifdef QCOM_FM_ENABLED
#define FM_DEVICE "/dev/msm_fm"
#define FM_A2DP_REC 1
#define FM_FILE_REC 2
#endif
#ifdef QCOM_ACDB_ENABLED
#define INVALID_ACDB_ID -1
#endif
namespace android_audio_legacy {
Mutex mDeviceSwitchLock;
#ifdef HTC_ACOUSTIC_AUDIO
Mutex mAIC3254ConfigLock;
#endif
static int audpre_index, tx_iir_index;
static void * acoustic;
const uint32_t AudioHardware::inputSamplingRates[] = {
8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000
};
static const uint32_t INVALID_DEVICE = 65535;
static const uint32_t SND_DEVICE_CURRENT = -1;
static const uint32_t SND_DEVICE_HANDSET = 0;
static const uint32_t SND_DEVICE_SPEAKER = 1;
static const uint32_t SND_DEVICE_HEADSET = 2;
static const uint32_t SND_DEVICE_FM_HANDSET = 3;
static const uint32_t SND_DEVICE_FM_SPEAKER = 4;
static const uint32_t SND_DEVICE_FM_HEADSET = 5;
static const uint32_t SND_DEVICE_BT = 6;
static const uint32_t SND_DEVICE_HEADSET_AND_SPEAKER = 7;
static const uint32_t SND_DEVICE_NO_MIC_HEADSET = 8;
static const uint32_t SND_DEVICE_IN_S_SADC_OUT_HANDSET = 9;
static const uint32_t SND_DEVICE_IN_S_SADC_OUT_SPEAKER_PHONE= 10;
static const uint32_t SND_DEVICE_TTY_HEADSET = 11;
static const uint32_t SND_DEVICE_TTY_HCO = 12;
static const uint32_t SND_DEVICE_TTY_VCO = 13;
static const uint32_t SND_DEVICE_TTY_FULL = 14;
static const uint32_t SND_DEVICE_HDMI = 15;
static const uint32_t SND_DEVICE_CARKIT = -1;
static const uint32_t SND_DEVICE_ANC_HEADSET = 16;
static const uint32_t SND_DEVICE_NO_MIC_ANC_HEADSET = 17;
static const uint32_t SND_DEVICE_HEADPHONE_AND_SPEAKER = 18;
static const uint32_t SND_DEVICE_FM_TX = 19;
static const uint32_t SND_DEVICE_FM_TX_AND_SPEAKER = 20;
static const uint32_t SND_DEVICE_SPEAKER_TX = 21;
static const uint32_t SND_DEVICE_BACK_MIC_CAMCORDER = 33;
#ifdef HTC_ACOUSTIC_AUDIO
static const uint32_t SND_DEVICE_SPEAKER_BACK_MIC = 26;
static const uint32_t SND_DEVICE_HANDSET_BACK_MIC = 27;
static const uint32_t SND_DEVICE_NO_MIC_HEADSET_BACK_MIC = 28;
static const uint32_t SND_DEVICE_HEADSET_AND_SPEAKER_BACK_MIC = 30;
static const uint32_t SND_DEVICE_I2S_SPEAKER = 32;
static const uint32_t SND_DEVICE_BT_EC_OFF = 45;
static const uint32_t SND_DEVICE_HAC = 252;
static const uint32_t SND_DEVICE_USB_HEADSET = 253;
#else
static const uint32_t SND_DEVICE_BT_EC_OFF = -1;
#endif
#ifdef SAMSUNG_AUDIO
static uint32_t SND_DEVICE_VOIP_HANDSET = 50;
static uint32_t SND_DEVICE_VOIP_SPEAKER = 51;
static uint32_t SND_DEVICE_VOIP_HEADSET = 52;
static uint32_t SND_DEVICE_CALL_HANDSET = 60;
static uint32_t SND_DEVICE_CALL_SPEAKER = 61;
static uint32_t SND_DEVICE_CALL_HEADSET = 62;
static uint32_t SND_DEVICE_VR_SPEAKER = 70;
static uint32_t SND_DEVICE_VR_HEADSET = 71;
static uint32_t SND_DEVICE_HAC = 252;
static uint32_t SND_DEVICE_USB_HEADSET = 253;
#endif
static const uint32_t DEVICE_HANDSET_RX = 0; // handset_rx
static const uint32_t DEVICE_HANDSET_TX = 1;//handset_tx
static const uint32_t DEVICE_SPEAKER_RX = 2; //speaker_stereo_rx
static const uint32_t DEVICE_SPEAKER_TX = 3;//speaker_mono_tx
static const uint32_t DEVICE_HEADSET_RX = 4; //headset_stereo_rx
static const uint32_t DEVICE_HEADSET_TX = 5; //headset_mono_tx
static const uint32_t DEVICE_FMRADIO_HANDSET_RX = 6; //fmradio_handset_rx
static const uint32_t DEVICE_FMRADIO_HEADSET_RX = 7; //fmradio_headset_rx
static const uint32_t DEVICE_FMRADIO_SPEAKER_RX = 8; //fmradio_speaker_rx
static const uint32_t DEVICE_DUALMIC_HANDSET_TX = 9; //handset_dual_mic_endfire_tx
static const uint32_t DEVICE_DUALMIC_SPEAKER_TX = 10; //speaker_dual_mic_endfire_tx
static const uint32_t DEVICE_TTY_HEADSET_MONO_RX = 11; //tty_headset_mono_rx
static const uint32_t DEVICE_TTY_HEADSET_MONO_TX = 12; //tty_headset_mono_tx
static const uint32_t DEVICE_SPEAKER_HEADSET_RX = 13; //headset_stereo_speaker_stereo_rx
static const uint32_t DEVICE_FMRADIO_STEREO_TX = 14;
static const uint32_t DEVICE_HDMI_STERO_RX = 15; //hdmi_stereo_rx
static const uint32_t DEVICE_ANC_HEADSET_STEREO_RX = 16; //ANC RX
static const uint32_t DEVICE_BT_SCO_RX = 17; //bt_sco_rx
static const uint32_t DEVICE_BT_SCO_TX = 18; //bt_sco_tx
static const uint32_t DEVICE_FMRADIO_STEREO_RX = 19;
#ifdef SAMSUNG_AUDIO
// Samsung devices
static uint32_t DEVICE_HANDSET_VOIP_RX = 40; // handset_voip_rx
static uint32_t DEVICE_HANDSET_VOIP_TX = 41; // handset_voip_tx
static uint32_t DEVICE_SPEAKER_VOIP_RX = 42; // speaker_voip_rx
static uint32_t DEVICE_SPEAKER_VOIP_TX = 43; // speaker_voip_tx
static uint32_t DEVICE_HEADSET_VOIP_RX = 44; // headset_voip_rx
static uint32_t DEVICE_HEADSET_VOIP_TX = 45; // headset_voip_tx
static uint32_t DEVICE_HANDSET_CALL_RX = 60; // handset_call_rx
static uint32_t DEVICE_HANDSET_CALL_TX = 61; // handset_call_tx
static uint32_t DEVICE_SPEAKER_CALL_RX = 62; // speaker_call_rx
static uint32_t DEVICE_SPEAKER_CALL_TX = 63; // speaker_call_tx
static uint32_t DEVICE_HEADSET_CALL_RX = 64; // headset_call_rx
static uint32_t DEVICE_HEADSET_CALL_TX = 65; // headset_call_tx
static uint32_t DEVICE_SPEAKER_VR_TX = 82; // speaker_vr_tx
static uint32_t DEVICE_HEADSET_VR_TX = 83; // headset_vr_tx
#endif
static uint32_t DEVICE_CAMCORDER_TX = 105; // camcoder_tx (misspelled by Samsung)
// secondary_mic_tx (sony)
static uint32_t FLUENCE_MODE_ENDFIRE = 0;
static uint32_t FLUENCE_MODE_BROADSIDE = 1;
static int vr_enable = 0;
int dev_cnt = 0;
const char ** name = NULL;
int mixer_cnt = 0;
static uint32_t cur_tx = INVALID_DEVICE;
static uint32_t cur_rx = INVALID_DEVICE;
#ifdef QCOM_VOIP_ENABLED
int voip_session_id = 0;
int voip_session_mute = 0;
#endif
int voice_session_id = 0;
int voice_session_mute = 0;
static bool dualmic_enabled = false;
static bool anc_running = false;
static bool anc_setting = false;
// This flag is used for avoiding multiple init/deinit of ANC driver.
static bool anc_enabled = false;
bool vMicMute = false;
#ifdef QCOM_ACDB_ENABLED
static bool bInitACDB = false;
#endif
#ifdef HTC_ACOUSTIC_AUDIO
int rx_htc_acdb = 0;
int tx_htc_acdb = 0;
static bool support_aic3254 = true;
static bool aic3254_enabled = true;
int (*set_sound_effect)(const char* effect);
static bool support_tpa2051 = true;
static bool support_htc_backmic = true;
static bool fm_enabled = false;
static int alt_enable = 0;
static int hac_enable = 0;
static uint32_t cur_aic_tx = UPLINK_OFF;
static uint32_t cur_aic_rx = DOWNLINK_OFF;
static int cur_tpa_mode = 0;
#endif
typedef struct routing_table
{
unsigned short dec_id;
int dev_id;
int dev_id_tx;
int stream_type;
bool active;
struct routing_table *next;
} Routing_table;
Routing_table* head;
Mutex mRoutingTableLock;
typedef struct device_table
{
int dev_id;
int acdb_id;
int class_id;
int capability;
}Device_table;
Device_table* device_list;
enum STREAM_TYPES {
PCM_PLAY=1,
PCM_REC,
#ifdef QCOM_TUNNEL_LPA_ENABLED
LPA_DECODE,
#endif
VOICE_CALL,
#ifdef QCOM_VOIP_ENABLED
VOIP_CALL,
#endif
#ifdef QCOM_FM_ENABLED
FM_RADIO,
FM_REC,
FM_A2DP,
#endif
INVALID_STREAM
};
typedef struct ComboDeviceType
{
uint32_t DeviceId;
STREAM_TYPES StreamType;
}CurrentComboDeviceStruct;
CurrentComboDeviceStruct CurrentComboDeviceData;
Mutex mComboDeviceLock;
#ifdef QCOM_FM_ENABLED
enum FM_STATE {
FM_INVALID=1,
FM_OFF,
FM_ON
};
FM_STATE fmState = FM_INVALID;
#endif
static uint32_t fmDevice = INVALID_DEVICE;
#define MAX_DEVICE_COUNT 200
#define DEV_ID(X) device_list[X].dev_id
#ifdef QCOM_ACDB_ENABLED
#define ACDB_ID(X) device_list[X].acdb_id
#endif
#define CAPABILITY(X) device_list[X].capability
void addToTable(int decoder_id,int device_id,int device_id_tx,int stream_type,bool active) {
Routing_table* temp_ptr;
ALOGD("addToTable stream %d",stream_type);
Mutex::Autolock lock(mRoutingTableLock);
temp_ptr = (Routing_table* ) malloc(sizeof(Routing_table));
temp_ptr->next = NULL;
temp_ptr->dec_id = decoder_id;
temp_ptr->dev_id = device_id;
temp_ptr->dev_id_tx = device_id_tx;
temp_ptr->stream_type = stream_type;
temp_ptr->active = active;
//make sure Voice node is always on top.
//For voice call device Switching, there a limitation
//Routing must happen before disabling/Enabling device.
if(head->next != NULL){
if(head->next->stream_type == VOICE_CALL){
temp_ptr->next = head->next->next;
head->next->next = temp_ptr;
return;
}
}
//add new Node to head.
temp_ptr->next =head->next;
head->next = temp_ptr;
}
bool isStreamOn(int Stream_type) {
Routing_table* temp_ptr;
Mutex::Autolock lock(mRoutingTableLock);
temp_ptr = head->next;
while(temp_ptr!=NULL) {
if(temp_ptr->stream_type == Stream_type)
return true;
temp_ptr=temp_ptr->next;
}
return false;
}
bool isStreamOnAndActive(int Stream_type) {
Routing_table* temp_ptr;
Mutex::Autolock lock(mRoutingTableLock);
temp_ptr = head->next;
while(temp_ptr!=NULL) {
if(temp_ptr->stream_type == Stream_type) {
if(temp_ptr->active == true) {
return true;
}
else {
return false;
}
}
temp_ptr=temp_ptr->next;
}
return false;
}
bool isStreamOnAndInactive(int Stream_type) {
Routing_table* temp_ptr;
Mutex::Autolock lock(mRoutingTableLock);
temp_ptr = head->next;
while(temp_ptr!=NULL) {
if(temp_ptr->stream_type == Stream_type) {
if(temp_ptr->active == false) {
return true;
}
else {
return false;
}
}
temp_ptr=temp_ptr->next;
}
return false;
}
Routing_table* getNodeByStreamType(int Stream_type) {
Routing_table* temp_ptr;
Mutex::Autolock lock(mRoutingTableLock);
temp_ptr = head->next;
while(temp_ptr!=NULL) {
if(temp_ptr->stream_type == Stream_type) {
return temp_ptr;
}
temp_ptr=temp_ptr->next;
}
return NULL;
}
void modifyActiveStateOfStream(int Stream_type, bool Active) {
Routing_table* temp_ptr;
Mutex::Autolock lock(mRoutingTableLock);
temp_ptr = head->next;
while(temp_ptr!=NULL) {
if(temp_ptr->stream_type == Stream_type) {
temp_ptr->active = Active;
}
temp_ptr=temp_ptr->next;
}
}
void modifyActiveDeviceOfStream(int Stream_type,int Device_id,int Device_id_tx) {
Routing_table* temp_ptr;
temp_ptr = head->next;
while(temp_ptr!=NULL) {
if(temp_ptr->stream_type == Stream_type) {
temp_ptr->dev_id = Device_id;
temp_ptr->dev_id_tx = Device_id_tx;
}
temp_ptr=temp_ptr->next;
}
}
void printTable()
{
Routing_table * temp_ptr;
Mutex::Autolock lock(mRoutingTableLock);
temp_ptr = head->next;
while(temp_ptr!=NULL) {
printf("%d %d %d %d %d\n",temp_ptr->dec_id,temp_ptr->dev_id,temp_ptr->dev_id_tx,temp_ptr->stream_type,temp_ptr->active);
temp_ptr = temp_ptr->next;
}
}
void deleteFromTable(int Stream_type) {
Routing_table *temp_ptr,*temp1;
ALOGD("deleteFromTable stream %d",Stream_type);
Mutex::Autolock lock(mRoutingTableLock);
temp_ptr = head;
while(temp_ptr->next!=NULL) {
if(temp_ptr->next->stream_type == Stream_type) {
temp1 = temp_ptr->next;
temp_ptr->next = temp_ptr->next->next;
free(temp1);
return;
}
temp_ptr=temp_ptr->next;
}
}
bool isDeviceListEmpty() {
if(head->next == NULL)
return true;
else
return false;
}
#ifdef QCOM_ANC_HEADSET_ENABLED
//NEEDS to be called with device already enabled
#define ANC_ACDB_STEREO_FF_ID 26
int enableANC(int enable, uint32_t device)
{
int rc;
device = 16;
ALOGD("%s: enable=%d, device=%d", __func__, enable, device);
// If anc is already enabled/disabled, then don't initalize the driver again.
if (enable == anc_enabled)
{
ALOGV("ANC driver is already in state %d. Not calling anc driver", enable);
return -EPERM;
}
if (enable) {
#ifdef QCOM_ACDB_ENABLED
rc = acdb_loader_send_anc_cal(ANC_ACDB_STEREO_FF_ID);
if (rc) {
ALOGE("Error processing ANC ACDB data\n");
return rc;
}
#endif
}
rc = msm_enable_anc(DEV_ID(device),enable);
if ( rc == 0 )
{
ALOGV("msm_enable_anc was successful");
anc_enabled = enable;
} else
{
ALOGV("msm_enable_anc failed");
}
return rc;
}
#endif
#ifdef QCOM_ACDB_ENABLED
static void initACDB() {
while(bInitACDB == false) {
ALOGD("Calling acdb_loader_init_ACDB()");
if(acdb_loader_init_ACDB() == 0){
ALOGD("acdb_loader_init_ACDB() successful");
bInitACDB = true;
}
}
}
#endif
int enableDevice(int device,short enable) {
// prevent disabling of a device if it doesn't exist
//Temporaray hack till speaker_tx device is mainlined
if(DEV_ID(device) == INVALID_DEVICE) {
return 0;
}
#ifdef QCOM_ACDB_ENABLED
if(bInitACDB == false) {
initACDB();
}
#endif
ALOGE("value of device and enable is %d %d ALSA dev id:%d",device,enable,DEV_ID(device));
if( msm_en_device(DEV_ID(device), enable)) {
ALOGE("msm_en_device(%d,%d) failed errno = %d",DEV_ID(device),enable, errno);
return -1;
}
return 0;
}
static status_t updateDeviceInfo(int rx_device,int tx_device) {
bool isRxDeviceEnabled = false,isTxDeviceEnabled = false;
Routing_table *temp_ptr,*temp_head;
int tx_dev_prev = INVALID_DEVICE;
temp_head = head;
ALOGD("updateDeviceInfo: E");
Mutex::Autolock lock(mDeviceSwitchLock);
if(temp_head->next == NULL) {
ALOGD("simple device switch");
if(cur_rx!=INVALID_DEVICE)
enableDevice(cur_rx,0);
if(cur_tx != INVALID_DEVICE)
enableDevice(cur_tx,0);
cur_rx = rx_device;
cur_tx = tx_device;
if(cur_rx == DEVICE_ANC_HEADSET_STEREO_RX) {
enableDevice(cur_rx,1);
enableDevice(cur_tx,1);
}
return NO_ERROR;
}
Mutex::Autolock lock_1(mRoutingTableLock);
while(temp_head->next != NULL) {
temp_ptr = temp_head->next;
switch(temp_ptr->stream_type) {
case PCM_PLAY:
#ifdef QCOM_TUNNEL_LPA_ENABLED
case LPA_DECODE:
#endif
#ifdef QCOM_FM_ENABLED
case FM_RADIO:
case FM_A2DP:
#endif
if(rx_device == INVALID_DEVICE)
return -1;
ALOGD("The node type is %d", temp_ptr->stream_type);
ALOGV("rx_device = %d,temp_ptr->dev_id = %d",rx_device,temp_ptr->dev_id);
if(rx_device != temp_ptr->dev_id) {
enableDevice(temp_ptr->dev_id,0);
}
if(msm_route_stream(PCM_PLAY,temp_ptr->dec_id,DEV_ID(temp_ptr->dev_id),0)) {
ALOGV("msm_route_stream(PCM_PLAY,%d,%d,0) failed",temp_ptr->dec_id,DEV_ID(temp_ptr->dev_id));
}
if(isRxDeviceEnabled == false) {
enableDevice(rx_device,1);
#ifdef QCOM_ACDB_ENABLED
acdb_loader_send_audio_cal(ACDB_ID(rx_device), CAPABILITY(rx_device));
#endif
isRxDeviceEnabled = true;
}
if(msm_route_stream(PCM_PLAY,temp_ptr->dec_id,DEV_ID(rx_device),1)) {
ALOGV("msm_route_stream(PCM_PLAY,%d,%d,1) failed",temp_ptr->dec_id,DEV_ID(rx_device));
}
modifyActiveDeviceOfStream(temp_ptr->stream_type,rx_device,INVALID_DEVICE);
cur_tx = tx_device ;
cur_rx = rx_device ;
break;
case PCM_REC:
if(tx_device == INVALID_DEVICE)
return -1;
// If dual mic is enabled in QualComm settings then that takes preference.
if ( dualmic_enabled && (DEV_ID(DEVICE_DUALMIC_SPEAKER_TX) != INVALID_DEVICE))
{
tx_device = DEVICE_DUALMIC_SPEAKER_TX;
}
ALOGD("case PCM_REC");
if(isTxDeviceEnabled == false) {
enableDevice(temp_ptr->dev_id,0);
enableDevice(tx_device,1);
#ifdef QCOM_ACDB_ENABLED
acdb_loader_send_audio_cal(ACDB_ID(tx_device), CAPABILITY(tx_device));
#endif
isTxDeviceEnabled = true;
}
if(msm_route_stream(PCM_REC,temp_ptr->dec_id,DEV_ID(temp_ptr->dev_id),0)) {
ALOGV("msm_route_stream(PCM_PLAY,%d,%d,0) failed",temp_ptr->dec_id,DEV_ID(temp_ptr->dev_id));
}
if(msm_route_stream(PCM_REC,temp_ptr->dec_id,DEV_ID(tx_device),1)) {
ALOGV("msm_route_stream(PCM_REC,%d,%d,1) failed",temp_ptr->dec_id,DEV_ID(tx_device));
}
modifyActiveDeviceOfStream(PCM_REC,tx_device,INVALID_DEVICE);
tx_dev_prev = cur_tx;
cur_tx = tx_device ;
cur_rx = rx_device ;
if((vMicMute == true) && (tx_dev_prev != cur_tx)) {
ALOGD("REC:device switch with mute enabled :tx_dev_prev %d cur_tx: %d",tx_dev_prev, cur_tx);
msm_device_mute(DEV_ID(cur_tx), true);
}
break;
case VOICE_CALL:
#ifdef QCOM_VOIP_ENABLED
case VOIP_CALL:
#endif
if(rx_device == INVALID_DEVICE || tx_device == INVALID_DEVICE)
return -1;
ALOGD("case VOICE_CALL/VOIP CALL %d",temp_ptr->stream_type);
#ifdef QCOM_ACDB_ENABLED
#ifdef HTC_ACOUSTIC_AUDIO
if (rx_htc_acdb == 0)
rx_htc_acdb = ACDB_ID(rx_device);
if (tx_htc_acdb == 0)
tx_htc_acdb = ACDB_ID(tx_device);
ALOGD("acdb_loader_send_voice_cal acdb_rx = %d, acdb_tx = %d", rx_htc_acdb, tx_htc_acdb);
acdb_loader_send_voice_cal(rx_htc_acdb, tx_htc_acdb);
#else
acdb_loader_send_voice_cal(ACDB_ID(rx_device),ACDB_ID(tx_device));
#endif
#endif
msm_route_voice(DEV_ID(rx_device),DEV_ID(tx_device),1);
// Temporary work around for Speaker mode. The driver is not
// supporting Speaker Rx and Handset Tx combo
if(isRxDeviceEnabled == false) {
if (rx_device != temp_ptr->dev_id)
{
enableDevice(temp_ptr->dev_id,0);
}
isRxDeviceEnabled = true;
}
if(isTxDeviceEnabled == false) {
if (tx_device != temp_ptr->dev_id_tx)
{
enableDevice(temp_ptr->dev_id_tx,0);
}
isTxDeviceEnabled = true;
}
if (rx_device != temp_ptr->dev_id)
{
enableDevice(rx_device,1);
}
if (tx_device != temp_ptr->dev_id_tx)
{
enableDevice(tx_device,1);
}
cur_rx = rx_device;
cur_tx = tx_device;
modifyActiveDeviceOfStream(temp_ptr->stream_type,cur_rx,cur_tx);
break;
default:
break;
}
temp_head = temp_head->next;
}
ALOGD("updateDeviceInfo: X");
return NO_ERROR;
}
void freeMemory() {
Routing_table *temp;
while(head != NULL) {
temp = head->next;
free(head);
head = temp;
}
free(device_list);
}
//
// ----------------------------------------------------------------------------
AudioHardware::AudioHardware() :
mInit(false), mMicMute(true), mBluetoothNrec(true), mBluetoothId(0),
#ifdef HTC_ACOUSTIC_AUDIO
mHACSetting(false), mBluetoothIdTx(0), mBluetoothIdRx(0),
#endif
mOutput(0),mBluetoothVGS(false),
mCurSndDevice(-1),
mTtyMode(TTY_OFF), mFmFd(-1), mNumPcmRec(0)
#ifdef QCOM_VOIP_ENABLED
, mVoipFd(-1), mNumVoipStreams(0), mDirectOutput(0)
#endif
#ifdef HTC_ACOUSTIC_AUDIO
, mRecordState(false), mEffectEnabled(false)
#endif
{
int control;
int i = 0,index = 0;
#ifdef QCOM_ACDB_ENABLED
int acdb_id = INVALID_ACDB_ID;
#endif
int fluence_mode = FLUENCE_MODE_ENDFIRE;
char value[128];
#ifdef HTC_ACOUSTIC_AUDIO
int (*snd_get_num)();
int (*snd_get_bt_endpoint)(msm_bt_endpoint *);
int (*set_acoustic_parameters)();
int (*set_tpa2051_parameters)();
int (*set_aic3254_parameters)();
int (*support_back_mic)();
struct msm_bt_endpoint *ept;
#endif
head = (Routing_table* ) malloc(sizeof(Routing_table));
head->next = NULL;
#ifdef HTC_ACOUSTIC_AUDIO
acoustic =:: dlopen("/system/lib/libhtc_acoustic.so", RTLD_NOW);
if (acoustic == NULL ) {
ALOGD("Could not open libhtc_acoustic.so");
/* this is not really an error on non-htc devices... */
mNumBTEndpoints = 0;
support_aic3254 = false;
support_tpa2051 = false;
support_htc_backmic = false;
}
#endif
ALOGD("msm_mixer_open: Opening the device");
control = msm_mixer_open("/dev/snd/controlC0", 0);
if(control< 0)
ALOGE("ERROR opening the device");
mixer_cnt = msm_mixer_count();
ALOGD("msm_mixer_count:mixer_cnt =%d",mixer_cnt);
dev_cnt = msm_get_device_count();
ALOGV("got device_count %d",dev_cnt);
if (dev_cnt <= 0) {
ALOGE("NO devices registered\n");
return;
}
//End any voice call if it exists. This is to ensure the next request
//to voice call after a mediaserver crash or sub system restart
//is not ignored by the voice driver.
if (msm_end_voice() < 0)
ALOGE("msm_end_voice() failed");
if(msm_reset_all_device() < 0)
ALOGE("msm_reset_all_device() failed");
name = msm_get_device_list();
device_list = (Device_table* )malloc(sizeof(Device_table)*MAX_DEVICE_COUNT);
if(device_list == NULL) {
ALOGE("malloc failed for device list");
return;
}
property_get("persist.audio.fluence.mode",value,"0");
if (!strcmp("broadside", value)) {
fluence_mode = FLUENCE_MODE_BROADSIDE;
}
property_get("persist.audio.vr.enable",value,"Unknown");
if (!strcmp("true", value))
vr_enable = 1;
for(i = 0;i<MAX_DEVICE_COUNT;i++)
device_list[i].dev_id = INVALID_DEVICE;
for(i = 0; i < dev_cnt;i++) {
if(strcmp((char* )name[i],"handset_rx") == 0) {
index = DEVICE_HANDSET_RX;
}
else if(strcmp((char* )name[i],"handset_tx") == 0) {
index = DEVICE_HANDSET_TX;
}
else if((strcmp((char* )name[i],"speaker_stereo_rx") == 0) ||
(strcmp((char* )name[i],"speaker_stereo_rx_playback") == 0) ||
(strcmp((char* )name[i],"speaker_rx") == 0)) {
index = DEVICE_SPEAKER_RX;
}
else if((strcmp((char* )name[i],"speaker_mono_tx") == 0) || (strcmp((char* )name[i],"speaker_tx") == 0)) {
index = DEVICE_SPEAKER_TX;
}
else if((strcmp((char* )name[i],"headset_stereo_rx") == 0) || (strcmp((char* )name[i],"headset_rx") == 0)) {
index = DEVICE_HEADSET_RX;
}
else if((strcmp((char* )name[i],"headset_mono_tx") == 0) || (strcmp((char* )name[i],"headset_tx") == 0)) {
index = DEVICE_HEADSET_TX;
}
else if(strcmp((char* )name[i],"fmradio_handset_rx") == 0) {
index = DEVICE_FMRADIO_HANDSET_RX;
}
else if((strcmp((char* )name[i],"fmradio_headset_rx") == 0) || (strcmp((char* )name[i],"fm_radio_headset_rx") == 0)) {
index = DEVICE_FMRADIO_HEADSET_RX;
}
else if((strcmp((char* )name[i],"fmradio_speaker_rx") == 0) || (strcmp((char* )name[i],"fm_radio_speaker_rx") == 0)) {
index = DEVICE_FMRADIO_SPEAKER_RX;
}
else if((strcmp((char* )name[i],"handset_dual_mic_endfire_tx") == 0) || (strcmp((char* )name[i],"dualmic_handset_ef_tx") == 0)) {
if (fluence_mode == FLUENCE_MODE_ENDFIRE) {
index = DEVICE_DUALMIC_HANDSET_TX;
} else {
ALOGV("Endfire handset found but user request for %d\n", fluence_mode);
continue;
}
}
else if((strcmp((char* )name[i],"speaker_dual_mic_endfire_tx") == 0)|| (strcmp((char* )name[i],"dualmic_speaker_ef_tx") == 0)) {
if (fluence_mode == FLUENCE_MODE_ENDFIRE) {
index = DEVICE_DUALMIC_SPEAKER_TX;
} else {
ALOGV("Endfire speaker found but user request for %d\n", fluence_mode);
continue;
}
}
else if(strcmp((char* )name[i],"handset_dual_mic_broadside_tx") == 0) {
if (fluence_mode == FLUENCE_MODE_BROADSIDE) {
index = DEVICE_DUALMIC_HANDSET_TX;
} else {
ALOGV("Broadside handset found but user request for %d\n", fluence_mode);
continue;
}
}
else if(strcmp((char* )name[i],"speaker_dual_mic_broadside_tx") == 0) {
if (fluence_mode == FLUENCE_MODE_BROADSIDE) {
index = DEVICE_DUALMIC_SPEAKER_TX;
} else {
ALOGV("Broadside speaker found but user request for %d\n", fluence_mode);
continue;
}
}
else if((strcmp((char* )name[i],"tty_headset_mono_rx") == 0) || (strcmp((char* )name[i],"tty_headset_rx") == 0)) {
index = DEVICE_TTY_HEADSET_MONO_RX;
}
else if((strcmp((char* )name[i],"tty_headset_mono_tx") == 0) || (strcmp((char* )name[i],"tty_headset_tx") == 0)) {
index = DEVICE_TTY_HEADSET_MONO_TX;
}
else if((strcmp((char* )name[i],"bt_sco_rx") == 0) || (strcmp((char* )name[i],"bt_sco_mono_rx") == 0)) {
index = DEVICE_BT_SCO_RX;
}
else if((strcmp((char* )name[i],"bt_sco_tx") == 0) || (strcmp((char* )name[i],"bt_sco_mono_tx") == 0)) {
index = DEVICE_BT_SCO_TX;
}
else if((strcmp((char*)name[i],"headset_stereo_speaker_stereo_rx") == 0) ||
(strcmp((char*)name[i],"headset_stereo_rx_playback") == 0) ||
(strcmp((char*)name[i],"headset_speaker_stereo_rx") == 0) || (strcmp((char*)name[i],"speaker_headset_rx") == 0)) {
index = DEVICE_SPEAKER_HEADSET_RX;
}
else if((strcmp((char*)name[i],"fmradio_stereo_tx") == 0) || (strcmp((char*)name[i],"fm_radio_tx") == 0)) {
index = DEVICE_FMRADIO_STEREO_TX;
}
else if((strcmp((char*)name[i],"hdmi_stereo_rx") == 0) || (strcmp((char*)name[i],"hdmi_rx") == 0)) {
index = DEVICE_HDMI_STERO_RX;
}
//to check for correct name and ACDB number for ANC
else if(strcmp((char*)name[i],"anc_headset_stereo_rx") == 0) {
index = DEVICE_ANC_HEADSET_STEREO_RX;
}
else if(strcmp((char*)name[i],"fmradio_stereo_rx") == 0)
index = DEVICE_FMRADIO_STEREO_RX;
#ifdef SAMSUNG_AUDIO
else if(strcmp((char* )name[i], "handset_voip_rx") == 0)
index = DEVICE_HANDSET_VOIP_RX;
else if(strcmp((char* )name[i], "handset_voip_tx") == 0)
index = DEVICE_HANDSET_VOIP_TX;
else if(strcmp((char* )name[i], "speaker_voip_rx") == 0)
index = DEVICE_SPEAKER_VOIP_RX;
else if(strcmp((char* )name[i], "speaker_voip_tx") == 0)
index = DEVICE_SPEAKER_VOIP_TX;
else if(strcmp((char* )name[i], "headset_voip_rx") == 0)
index = DEVICE_HEADSET_VOIP_RX;
else if(strcmp((char* )name[i], "headset_voip_tx") == 0)
index = DEVICE_HEADSET_VOIP_TX;
else if(strcmp((char* )name[i], "handset_call_rx") == 0)
index = DEVICE_HANDSET_CALL_RX;
else if(strcmp((char* )name[i], "handset_call_tx") == 0)
index = DEVICE_HANDSET_CALL_TX;
else if(strcmp((char* )name[i], "speaker_call_rx") == 0)
index = DEVICE_SPEAKER_CALL_RX;
else if(strcmp((char* )name[i], "speaker_call_tx") == 0)
index = DEVICE_SPEAKER_CALL_TX;
else if(strcmp((char* )name[i], "headset_call_rx") == 0)
index = DEVICE_HEADSET_CALL_RX;
else if(strcmp((char* )name[i], "headset_call_tx") == 0)
index = DEVICE_HEADSET_CALL_TX;
else if(strcmp((char* )name[i], "speaker_vr_tx") == 0)
index = DEVICE_SPEAKER_VR_TX;
else if(strcmp((char* )name[i], "headset_vr_tx") == 0)
index = DEVICE_HEADSET_VR_TX;
#endif
else if((strcmp((char* )name[i], "camcoder_tx") == 0) ||
#ifdef SONY_AUDIO
(strcmp((char* )name[i], "secondary_mic_tx") == 0))
#else
(strcmp((char* )name[i], "camcorder_tx") == 0) ||
(strcmp((char* )name[i], "handset_lgcam_tx") == 0))
#endif
index = DEVICE_CAMCORDER_TX;
else {
ALOGI("Not used device: %s", ( char* )name[i]);
continue;
}
ALOGI("index = %d",index);
device_list[index].dev_id = msm_get_device((char* )name[i]);
if(device_list[index].dev_id >= 0) {
ALOGI("Found device: %s:index = %d,dev_id: %d",( char* )name[i], index,device_list[index].dev_id);
}
#ifdef QCOM_ACDB_ENABLED
acdb_mapper_get_acdb_id_from_dev_name((char* )name[i], &device_list[index].acdb_id);
device_list[index].class_id = msm_get_device_class(device_list[index].dev_id);
device_list[index].capability = msm_get_device_capability(device_list[index].dev_id);
ALOGI("acdb ID = %d,class ID = %d,capablity = %d for device %d",device_list[index].acdb_id,
device_list[index].class_id,device_list[index].capability,device_list[index].dev_id);
#endif
}
CurrentComboDeviceData.DeviceId = INVALID_DEVICE;
CurrentComboDeviceData.StreamType = INVALID_STREAM;
#ifdef HTC_ACOUSTIC_AUDIO
set_acoustic_parameters = (int (*)(void))::dlsym(acoustic, "set_acoustic_parameters");
if ((*set_acoustic_parameters) == 0 ) {
ALOGE("Could not open set_acoustic_parameters()");
return;
}
int rc = set_acoustic_parameters();
if (rc < 0) {
ALOGD("Could not set acoustic parameters to share memory: %d", rc);
}
/* Check the system property for enable or not the ALT function */
property_get("htc.audio.alt.enable", value, "0");
alt_enable = atoi(value);
ALOGV("Enable ALT function: %d", alt_enable);
/* Check the system property for enable or not the HAC function */
property_get("htc.audio.hac.enable", value, "0");
hac_enable = atoi(value);
ALOGV("Enable HAC function: %d", hac_enable);
set_tpa2051_parameters = (int (*)(void))::dlsym(acoustic, "set_tpa2051_parameters");
if ((*set_tpa2051_parameters) == 0) {
ALOGI("set_tpa2051_parameters() not present");
support_tpa2051 = false;
}
if (support_tpa2051) {
if (set_tpa2051_parameters() < 0) {
ALOGI("Speaker amplifies tpa2051 is not supported");
support_tpa2051 = false;
}
}
set_aic3254_parameters = (int (*)(void))::dlsym(acoustic, "set_aic3254_parameters");
if ((*set_aic3254_parameters) == 0 ) {
ALOGI("set_aic3254_parameters() not present");
support_aic3254 = false;
}
if (support_aic3254) {
if (set_aic3254_parameters() < 0) {
ALOGI("AIC3254 DSP is not supported");
support_aic3254 = false;
}
}
if (support_aic3254) {
set_sound_effect = (int (*)(const char*))::dlsym(acoustic, "set_sound_effect");
if ((*set_sound_effect) == 0 ) {
ALOGI("set_sound_effect() not present");
ALOGI("AIC3254 DSP is not supported");
support_aic3254 = false;
} else
strcpy(mEffect, "\0");
}
support_back_mic = (int (*)(void))::dlsym(acoustic, "support_back_mic");
if ((*support_back_mic) == 0 ) {
ALOGI("support_back_mic() not present");
support_htc_backmic = false;
}
if (support_htc_backmic) {
if (support_back_mic() != 1) {
ALOGI("HTC DualMic is not supported");
support_htc_backmic = false;
}
}
snd_get_num = (int (*)(void))::dlsym(acoustic, "snd_get_num");
if ((*snd_get_num) == 0 ) {
ALOGD("Could not open snd_get_num()");
}
mNumBTEndpoints = snd_get_num();
ALOGV("mNumBTEndpoints = %d", mNumBTEndpoints);
mBTEndpoints = new msm_bt_endpoint[mNumBTEndpoints];
ALOGV("constructed %d SND endpoints)", mNumBTEndpoints);
ept = mBTEndpoints;
snd_get_bt_endpoint = (int (*)(msm_bt_endpoint *))::dlsym(acoustic, "snd_get_bt_endpoint");
if ((*snd_get_bt_endpoint) == 0 ) {
mInit = true;
ALOGE("Could not open snd_get_bt_endpoint()");
return;
}
snd_get_bt_endpoint(mBTEndpoints);
for (int i = 0; i < mNumBTEndpoints; i++) {
ALOGV("BT name %s (tx,rx)=(%d,%d)", mBTEndpoints[i].name, mBTEndpoints[i].tx, mBTEndpoints[i].rx);
}
#endif
mInit = true;
}
AudioHardware::~AudioHardware()
{
for (size_t index = 0; index < mInputs.size(); index++) {
closeInputStream((AudioStreamIn*)mInputs[index]);
}
mInputs.clear();
#ifdef QCOM_VOIP_ENABLED
mVoipInputs.clear();
#endif
closeOutputStream((AudioStreamOut*)mOutput);
if (acoustic) {
::dlclose(acoustic);
acoustic = 0;
}
msm_mixer_close();
#ifdef QCOM_ACDB_ENABLED
acdb_loader_deallocate_ACDB();
#endif
freeMemory();
mInit = false;
}
status_t AudioHardware::initCheck()
{
return mInit ? NO_ERROR : NO_INIT;
}
AudioStreamOut* AudioHardware::openOutputStream(
uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status)
{
{ // scope for the lock
status_t lStatus;
audio_output_flags_t flags = static_cast<audio_output_flags_t> (*status);
Mutex::Autolock lock(mLock);
#ifdef QCOM_VOIP_ENABLED
// only one output stream allowed
if (mOutput && !((flags & AUDIO_OUTPUT_FLAG_DIRECT) && (flags & AUDIO_OUTPUT_FLAG_VOIP_RX))
&& !(flags & AUDIO_OUTPUT_FLAG_LPA)) {
if (status) {
*status = INVALID_OPERATION;
}
ALOGE(" AudioHardware::openOutputStream Only one output stream allowed \n");
return 0;
}
if ((flags & AUDIO_OUTPUT_FLAG_DIRECT) && (flags & AUDIO_OUTPUT_FLAG_VOIP_RX)) {
// open direct output stream
if(mDirectOutput == 0) {
ALOGV(" AudioHardware::openOutputStream Direct output stream \n");
AudioStreamOutDirect* out = new AudioStreamOutDirect();
lStatus = out->set(this, devices, format, channels, sampleRate);
if (status) {
*status = lStatus;
}
if (lStatus == NO_ERROR) {
mDirectOutput = out;
ALOGV(" \n set sucessful for AudioStreamOutDirect");
} else {
ALOGE(" \n set Failed for AudioStreamOutDirect");
delete out;
}
}
else {
ALOGE(" \n AudioHardware::AudioStreamOutDirect is already open");
}
return mDirectOutput;
} else
#endif
if (flags & AUDIO_OUTPUT_FLAG_LPA) {
status_t err = BAD_VALUE;
#if 0
if (mOutput) {
if (status) {
*status = INVALID_OPERATION;
}
ALOGE(" AudioHardware::openOutputStream Only one output stream allowed \n");
return 0;
}
#endif
// create new output LPA stream
AudioSessionOutLPA* out = NULL;
#ifdef QCOM_TUNNEL_LPA_ENABLED
out = new AudioSessionOutLPA(this, devices, *format, *channels,*sampleRate,0,&err);
if(err != NO_ERROR) {
delete out;
out = NULL;
}
#endif
if (status) *status = err;
mOutputLPA = out;
return mOutputLPA;
} else {
#if 0
ALOGV(" AudioHardware::openOutputStream AudioStreamOutMSM8x60 output stream \n");
// only one output stream allowed
if (mOutput) {
if (status) {
*status = INVALID_OPERATION;
}
ALOGE(" AudioHardware::openOutputStream Only one output stream allowed \n");
return 0;
}
#endif
// create new output stream
AudioStreamOutMSM8x60* out = new AudioStreamOutMSM8x60();
lStatus = out->set(this, devices, format, channels, sampleRate);
if (status) {
*status = lStatus;
}
if (lStatus == NO_ERROR) {
mOutput = out;
} else {
delete out;
}
return mOutput;
}
}
return NULL;
}
void AudioHardware::closeOutputStream(AudioStreamOut* out) {
Mutex::Autolock lock(mLock);
if ((mOutput == 0
#ifdef QCOM_VOIP_ENABLED
&& mDirectOutput == 0
#endif
&& mOutputLPA == 0) || ((mOutput != out)
#ifdef QCOM_VOIP_ENABLED
&& (mDirectOutput != out)
#endif
&& (mOutputLPA != out))) {
ALOGW("Attempt to close invalid output stream");
}
else if (mOutput == out) {
delete mOutput;
mOutput = 0;
}
#ifdef QCOM_VOIP_ENABLED
else if (mDirectOutput == out) {
ALOGV(" deleting mDirectOutput \n");
delete mDirectOutput;
mDirectOutput = 0;
}
#endif
else if (mOutputLPA == out) {
ALOGV(" deleting mOutputLPA \n");
delete mOutputLPA;
mOutputLPA = 0;
}
}
AudioStreamIn* AudioHardware::openInputStream(
uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status,
AudioSystem::audio_in_acoustics acoustic_flags)
{
// check for valid input source
if (!AudioSystem::isInputDevice((AudioSystem::audio_devices)devices)) {
return 0;
}
mLock.lock();
#ifdef QCOM_VOIP_ENABLED
if(devices == AudioSystem::DEVICE_IN_COMMUNICATION) {
ALOGE("Create Audio stream Voip \n");
AudioStreamInVoip* inVoip = new AudioStreamInVoip();
status_t lStatus = NO_ERROR;
lStatus = inVoip->set(this, devices, format, channels, sampleRate, acoustic_flags);
if (status) {
*status = lStatus;
}
if (lStatus != NO_ERROR) {
ALOGE(" Error creating voip input \n");
mLock.unlock();
delete inVoip;
return 0;
}
mVoipInputs.add(inVoip);
mLock.unlock();
return inVoip;
} else
#endif
{
AudioStreamInMSM8x60* in8x60 = new AudioStreamInMSM8x60();
status_t lStatus = in8x60->set(this, devices, format, channels, sampleRate, acoustic_flags);
if (status) {
*status = lStatus;
}
if (lStatus != NO_ERROR) {
ALOGE("Error creating Audio stream AudioStreamInMSM8x60 \n");
mLock.unlock();
delete in8x60;
return 0;
}
mInputs.add(in8x60);
mLock.unlock();
return in8x60;
}
}
void AudioHardware::closeInputStream(AudioStreamIn* in) {
Mutex::Autolock lock(mLock);
ssize_t index = -1;
if((index = mInputs.indexOf((AudioStreamInMSM8x60 *)in)) >= 0) {
ALOGV("closeInputStream AudioStreamInMSM8x60");
mLock.unlock();
delete mInputs[index];
mLock.lock();
mInputs.removeAt(index);
}
#ifdef QCOM_VOIP_ENABLED
else if ((index = mVoipInputs.indexOf((AudioStreamInVoip *)in)) >= 0) {
ALOGV("closeInputStream mVoipInputs");
mLock.unlock();
delete mVoipInputs[index];
mLock.lock();
mInputs.removeAt(index);
}
#endif
else {
ALOGE("Attempt to close invalid input stream");
}
}
status_t AudioHardware::setMode(int mode)
{
status_t status = AudioHardwareBase::setMode(mode);
if (status == NO_ERROR) {
// make sure that doAudioRouteOrMute() is called by doRouting()
// even if the new device selected is the same as current one.
clearCurDevice();
}
return status;
}
bool AudioHardware::checkOutputStandby()
{
if (mOutput)
if (!mOutput->checkStandby())
return false;
return true;
}
status_t AudioHardware::setMicMute(bool state)
{
Mutex::Autolock lock(mLock);
return setMicMute_nosync(state);
}
// always call with mutex held
status_t AudioHardware::setMicMute_nosync(bool state)
{
int session_id = 0;
if (mMicMute != state) {
mMicMute = state;
ALOGD("setMicMute_nosync calling voice mute with the mMicMute %d", mMicMute);
if(isStreamOnAndActive(VOICE_CALL)) {
session_id = voice_session_id;
voice_session_mute = mMicMute;
#ifdef QCOM_VOIP_ENABLED
} else if (isStreamOnAndActive(VOIP_CALL)) {
session_id = voip_session_id;
voip_session_mute = mMicMute;
#endif
} else {
ALOGE(" unknown voice stream");
return -1;
}
#ifdef LEGACY_QCOM_VOICE
msm_set_voice_tx_mute(mMicMute);
#else
msm_set_voice_tx_mute_ext(mMicMute,session_id);
#endif
}
return NO_ERROR;
}
status_t AudioHardware::getMicMute(bool* state)
{
int session_id = 0;
if(isStreamOnAndActive(VOICE_CALL)) {
session_id = voice_session_id;
*state = mMicMute = voice_session_mute;
#ifdef QCOM_VOIP_ENABLED
} else if (isStreamOnAndActive(VOIP_CALL)) {
session_id = voip_session_id;
*state = mMicMute = voip_session_mute;
#endif
} else
*state = mMicMute;
return NO_ERROR;
}
status_t AudioHardware::setParameters(const String8& keyValuePairs)
{
AudioParameter param = AudioParameter(keyValuePairs);
int rc = 0;
String8 value;
String8 key;
const char BT_NREC_KEY[] = "bt_headset_nrec";
const char BT_NAME_KEY[] = "bt_headset_name";
const char BT_NREC_VALUE_ON[] = "on";
#ifdef QCOM_FM_ENABLED
const char FM_NAME_KEY[] = "FMRadioOn";
const char FM_VALUE_HANDSET[] = "handset";
const char FM_VALUE_SPEAKER[] = "speaker";
const char FM_VALUE_HEADSET[] = "headset";
const char FM_VALUE_FALSE[] = "false";
#endif
#ifdef HTC_ACOUSTIC_AUDIO
const char ACTIVE_AP[] = "active_ap";
const char EFFECT_ENABLED[] = "sound_effect_enable";
#endif
ALOGV("setParameters() %s", keyValuePairs.string());
if (keyValuePairs.length() == 0) return BAD_VALUE;
key = String8(BT_NREC_KEY);
if (param.get(key, value) == NO_ERROR) {
if (value == BT_NREC_VALUE_ON) {
mBluetoothNrec = true;
} else {
mBluetoothNrec = false;
ALOGI("Turning noise reduction and echo cancellation off for BT "
"headset");
}
}
key = String8(BTHEADSET_VGS);
if (param.get(key, value) == NO_ERROR) {
if (value == BT_NREC_VALUE_ON) {
mBluetoothVGS = true;
} else {
mBluetoothVGS = false;
}
}
key = String8(BT_NAME_KEY);
if (param.get(key, value) == NO_ERROR) {
#ifdef HTC_ACOUSTIC_AUDIO
mBluetoothIdTx = 0;
mBluetoothIdRx = 0;
for (int i = 0; i < mNumBTEndpoints; i++) {
if (!strcasecmp(value.string(), mBTEndpoints[i].name)) {
mBluetoothIdTx = mBTEndpoints[i].tx;
mBluetoothIdRx = mBTEndpoints[i].rx;
ALOGD("Using custom acoustic parameters for %s", value.string());
break;
}
}
if (mBluetoothIdTx == 0) {
ALOGD("Using default acoustic parameters "
"(%s not in acoustic database)", value.string());
}
#endif
doRouting(NULL);
}
key = String8(DUALMIC_KEY);
if (param.get(key, value) == NO_ERROR) {
if (value == "true") {
dualmic_enabled = true;
ALOGI("DualMic feature Enabled");
} else {
dualmic_enabled = false;
ALOGI("DualMic feature Disabled");
}
doRouting(NULL);
}
#ifdef QCOM_ANC_HEADSET_ENABLED
key = String8(ANC_KEY);
if (param.get(key, value) == NO_ERROR) {
if (value == "true") {
ALOGE("Enabling ANC setting in the setparameter\n");
anc_setting= true;
} else {
ALOGE("Disabling ANC setting in the setparameter\n");
anc_setting= false;
//disabling ANC feature.
enableANC(0,cur_rx);
anc_running = false;
}
doRouting(NULL);
}
#endif
key = String8(TTY_MODE_KEY);
if (param.get(key, value) == NO_ERROR) {
if (value == "full") {
mTtyMode = TTY_FULL;
} else if (value == "hco") {
mTtyMode = TTY_HCO;
} else if (value == "vco") {
mTtyMode = TTY_VCO;
} else {
mTtyMode = TTY_OFF;
}
if(mMode != AudioSystem::MODE_IN_CALL){
return NO_ERROR;
}
ALOGI("Changed TTY Mode=%s", value.string());
if((mMode == AudioSystem::MODE_IN_CALL) &&
(cur_rx == DEVICE_HEADSET_RX) &&
(cur_tx == DEVICE_HEADSET_TX))
doRouting(NULL);
}
#ifdef HTC_ACOUSTIC_AUDIO
key = String8(ACTIVE_AP);
if (param.get(key, value) == NO_ERROR) {
const char* active_ap = value.string();
ALOGD("Active AP = %s", active_ap);
strcpy(mActiveAP, active_ap);
const char* dsp_effect = "\0";
key = String8(DSP_EFFECT_KEY);
if (param.get(key, value) == NO_ERROR) {
ALOGD("DSP Effect = %s", value.string());
dsp_effect = value.string();
strcpy(mEffect, dsp_effect);
}
key = String8(EFFECT_ENABLED);
if (param.get(key, value) == NO_ERROR) {
const char* sound_effect_enable = value.string();
ALOGD("Sound Effect Enabled = %s", sound_effect_enable);
if (value == "on") {
mEffectEnabled = true;
if (support_aic3254)
aic3254_config(get_snd_dev());
} else {
strcpy(mEffect, "\0");
mEffectEnabled = false;
}
}
}
#endif
return NO_ERROR;
}
String8 AudioHardware::getParameters(const String8& keys)
{
AudioParameter param = AudioParameter(keys);
String8 value;
String8 key = String8(DUALMIC_KEY);
if (param.get(key, value) == NO_ERROR) {
value = String8(dualmic_enabled ? "true" : "false");
param.add(key, value);
}
#ifdef QCOM_FM_ENABLED
key = String8("Fm-radio");
if ( param.get(key,value) == NO_ERROR ) {
if ( getNodeByStreamType(FM_RADIO) ) {
param.addInt(String8("isFMON"), true );
}
}
#endif
key = String8(BTHEADSET_VGS);
if (param.get(key, value) == NO_ERROR) {
if(mBluetoothVGS)
param.addInt(String8("isVGS"), true);
}
key = String8(ECHO_SUPRESSION);
if (param.get(key, value) == NO_ERROR) {
value = String8("yes");
param.add(key, value);
}
#ifdef HTC_ACOUSTIC_AUDIO
key = String8(DSP_EFFECT_KEY);
if (param.get(key, value) == NO_ERROR) {
value = String8(mCurDspProfile);
param.add(key, value);
}
#endif
ALOGV("AudioHardware::getParameters() %s", param.toString().string());
return param.toString();
}
static unsigned calculate_audpre_table_index(unsigned index)
{
switch (index) {
case 48000: return SAMP_RATE_INDX_48000;
case 44100: return SAMP_RATE_INDX_44100;
case 32000: return SAMP_RATE_INDX_32000;
case 24000: return SAMP_RATE_INDX_24000;
case 22050: return SAMP_RATE_INDX_22050;
case 16000: return SAMP_RATE_INDX_16000;
case 12000: return SAMP_RATE_INDX_12000;
case 11025: return SAMP_RATE_INDX_11025;
case 8000: return SAMP_RATE_INDX_8000;
default: return -1;
}
}
size_t AudioHardware::getInputBufferSize(uint32_t sampleRate, int format, int channelCount)
{
if (format != AudioSystem::PCM_16_BIT){
ALOGW("getInputBufferSize bad format: %d", format);
return 0;
}
if (channelCount < 1 || channelCount > 2) {
ALOGW("getInputBufferSize bad channel count: %d", channelCount);
return 0;
}
if (sampleRate == 8000) {
return 320*channelCount;
} else if (sampleRate == 16000){
return 640*channelCount;
} else {
/*
Return pcm record buffer size based on the sampling rate:
If sampling rate >= 44.1 Khz, use 512 samples/channel pcm recording and
If sampling rate < 44.1 Khz, use 256 samples/channel pcm recording
*/
if(sampleRate >= 44100){
return 1024*channelCount;
} else {
return 512*channelCount;
}
}
}
static status_t set_volume_rpc(uint32_t device,
uint32_t method,
uint32_t volume)
{
ALOGV("set_volume_rpc(%d, %d, %d)\n", device, method, volume);
if (device == -1UL) return NO_ERROR;
return NO_ERROR;
}
status_t AudioHardware::setVoiceVolume(float v)
{
int session_id = 0;
if (v < 0.0) {
ALOGW("setVoiceVolume(%f) under 0.0, assuming 0.0\n", v);
v = 0.0;
} else if (v > 1.0) {
ALOGW("setVoiceVolume(%f) over 1.0, assuming 1.0\n", v);
v = 1.0;
}
#ifdef HTC_ACOUSTIC_AUDIO
mVoiceVolume = v;
#endif
if(isStreamOnAndActive(VOICE_CALL)) {
session_id = voice_session_id;
}
#ifdef QCOM_VOIP_ENABLED
else if (isStreamOnAndActive(VOIP_CALL)) {
session_id = voip_session_id;
}
#endif
else {
ALOGE(" unknown stream ");
return -1;
}
int vol = lrint(v * 100.0);
// Voice volume levels from android are mapped to driver volume levels as follows.
// 0 -> 5, 20 -> 4, 40 ->3, 60 -> 2, 80 -> 1, 100 -> 0
vol = 5 - (vol/20);
ALOGD("setVoiceVolume(%f)\n", v);
ALOGI("Setting in-call volume to %d (available range is 5(MIN VOLUME) to 0(MAX VOLUME)\n", vol);
#ifdef LEGACY_QCOM_VOICE
if (msm_set_voice_rx_vol(vol)) {
ALOGE("msm_set_voice_rx_vol(%d) failed errno = %d", vol, errno);
return -1;
}
#else
if(msm_set_voice_rx_vol_ext(vol,session_id)) {
ALOGE("msm_set_voice_rx_vol(%d) failed errno = %d",vol,errno);
return -1;
}
#endif
ALOGV("msm_set_voice_rx_vol(%d) succeeded session_id %d",vol,session_id);
return NO_ERROR;
}
#ifdef QCOM_FM_ENABLED
status_t AudioHardware::setFmVolume(float v)
{
int vol = android::AudioSystem::logToLinear( (v?(v + 0.005):v) );
if ( vol > 100 ) {
vol = 100;
}
else if ( vol < 0 ) {
vol = 0;
}
ALOGV("setFmVolume(%f)\n", v);
ALOGV("Setting FM volume to %d (available range is 0 to 100)\n", vol);
Routing_table* temp = NULL;
temp = getNodeByStreamType(FM_RADIO);
if(temp == NULL){
ALOGV("No Active FM stream is running");
return NO_ERROR;
}
if(msm_set_volume(temp->dec_id, vol)) {
ALOGE("msm_set_volume(%d) failed for FM errno = %d",vol,errno);
return -1;
}
ALOGV("msm_set_volume(%d) for FM succeeded",vol);
return NO_ERROR;
}
#endif
status_t AudioHardware::setMasterVolume(float v)
{
Mutex::Autolock lock(mLock);
int vol = ceil(v * 7.0);
ALOGI("Set master volume to %d.\n", vol);
set_volume_rpc(SND_DEVICE_HANDSET, SND_METHOD_VOICE, vol);
set_volume_rpc(SND_DEVICE_SPEAKER, SND_METHOD_VOICE, vol);
set_volume_rpc(SND_DEVICE_BT, SND_METHOD_VOICE, vol);
set_volume_rpc(SND_DEVICE_HEADSET, SND_METHOD_VOICE, vol);
//TBD - does HDMI require this handling
// We return an error code here to let the audioflinger do in-software
// volume on top of the maximum volume that we set through the SND API.
// return error - software mixer will handle it
return -1;
}
#ifdef HTC_ACOUSTIC_AUDIO
status_t get_batt_temp(int *batt_temp) {
ALOGD("Enable ALT for speaker");
int i, fd, len;
char get_batt_temp[6] = { 0 };
const char *fn = "/sys/class/power_supply/battery/batt_temp";
if ((fd = open(fn, O_RDONLY)) < 0) {
ALOGE("Couldn't open sysfs file batt_temp");
return UNKNOWN_ERROR;
}
if ((len = read(fd, get_batt_temp, sizeof(get_batt_temp))) <= 1) {
ALOGE("read battery temp fail: %s", strerror(errno));
close(fd);
return BAD_VALUE;
}
*batt_temp = strtol(get_batt_temp, NULL, 10);
ALOGD("ALT batt_temp = %d", *batt_temp);
close(fd);
return NO_ERROR;
}
status_t do_tpa2051_control(int mode)
{
int fd, rc;
int tpa_mode = 0;
if (mode) {
if (cur_rx == DEVICE_HEADSET_RX)
tpa_mode = TPA2051_MODE_VOICECALL_HEADSET;
else if (cur_rx == DEVICE_SPEAKER_RX)
tpa_mode = TPA2051_MODE_VOICECALL_SPKR;
} else {
switch (cur_rx) {
case DEVICE_FMRADIO_HEADSET_RX:
tpa_mode = TPA2051_MODE_FM_HEADSET;
break;
case DEVICE_FMRADIO_SPEAKER_RX:
tpa_mode = TPA2051_MODE_FM_SPKR;
break;
case DEVICE_SPEAKER_HEADSET_RX:
tpa_mode = TPA2051_MODE_RING;
break;
case DEVICE_HEADSET_RX:
tpa_mode = TPA2051_MODE_PLAYBACK_HEADSET;
break;
case DEVICE_SPEAKER_RX:
tpa_mode = TPA2051_MODE_PLAYBACK_SPKR;
break;
default:
break;
}
}
fd = open("/dev/tpa2051d3", O_RDWR);
if (fd < 0) {
ALOGE("can't open /dev/tpa2051d3 %d", fd);
return -1;
}
if (tpa_mode != cur_tpa_mode) {
cur_tpa_mode = tpa_mode;
rc = ioctl(fd, TPA2051_SET_MODE, &tpa_mode);
if (rc < 0)
ALOGE("ioctl TPA2051_SET_MODE failed: %s", strerror(errno));
else
ALOGD("update TPA2051_SET_MODE to mode %d success", tpa_mode);
}
close(fd);
return 0;
}
#endif
static status_t do_route_audio_rpc(uint32_t device,
int mode, bool mic_mute)
{
if(device == -1)
return 0;
int new_rx_device = INVALID_DEVICE,new_tx_device = INVALID_DEVICE,fm_device = INVALID_DEVICE;
Routing_table* temp = NULL;
ALOGV("do_route_audio_rpc(%d, %d, %d)", device, mode, mic_mute);
if(device == SND_DEVICE_HANDSET) {
new_rx_device = DEVICE_HANDSET_RX;
new_tx_device = DEVICE_HANDSET_TX;
ALOGV("In HANDSET");
}
else if(device == SND_DEVICE_SPEAKER) {
new_rx_device = DEVICE_SPEAKER_RX;
new_tx_device = DEVICE_SPEAKER_TX;
ALOGV("In SPEAKER");
}
else if(device == SND_DEVICE_HEADSET) {
new_rx_device = DEVICE_HEADSET_RX;
new_tx_device = DEVICE_HEADSET_TX;
ALOGV("In HEADSET");
}
else if(device == SND_DEVICE_NO_MIC_HEADSET) {
new_rx_device = DEVICE_HEADSET_RX;
new_tx_device = DEVICE_HANDSET_TX;
ALOGV("In NO MIC HEADSET");
}
#ifdef QCOM_FM_ENABLED
else if (device == SND_DEVICE_FM_HANDSET) {
fm_device = DEVICE_FMRADIO_HANDSET_RX;
ALOGV("In FM HANDSET");
}
else if(device == SND_DEVICE_FM_SPEAKER) {
fm_device = DEVICE_FMRADIO_SPEAKER_RX;
ALOGV("In FM SPEAKER");
}
else if(device == SND_DEVICE_FM_HEADSET) {
fm_device = DEVICE_FMRADIO_HEADSET_RX;
ALOGV("In FM HEADSET");
}
#endif
#ifdef SAMSUNG_AUDIO
else if(device == SND_DEVICE_IN_S_SADC_OUT_HANDSET) {
new_rx_device = DEVICE_HANDSET_CALL_RX;
new_tx_device = DEVICE_DUALMIC_HANDSET_TX;
ALOGV("In DUALMIC_CALL_HANDSET");
if(DEV_ID(new_tx_device) == INVALID_DEVICE) {
new_tx_device = DEVICE_HANDSET_CALL_TX;
ALOGV("Falling back to HANDSET_CALL_RX AND HANDSET_CALL_TX as no DUALMIC_HANDSET_TX support found");
}
}
#else
else if(device == SND_DEVICE_IN_S_SADC_OUT_HANDSET) {
new_rx_device = DEVICE_HANDSET_RX;
new_tx_device = DEVICE_DUALMIC_HANDSET_TX;
ALOGV("In DUALMIC_HANDSET");
if(DEV_ID(new_tx_device) == INVALID_DEVICE) {
new_tx_device = DEVICE_HANDSET_TX;
ALOGV("Falling back to HANDSET_RX AND HANDSET_TX as no DUALMIC_HANDSET_TX support found");
}
}
#endif
else if(device == SND_DEVICE_IN_S_SADC_OUT_SPEAKER_PHONE) {
new_rx_device = DEVICE_SPEAKER_RX;
new_tx_device = DEVICE_DUALMIC_SPEAKER_TX;
ALOGV("In DUALMIC_SPEAKER");
if(DEV_ID(new_tx_device) == INVALID_DEVICE) {
new_tx_device = DEVICE_SPEAKER_TX;
ALOGV("Falling back to SPEAKER_RX AND SPEAKER_TX as no DUALMIC_SPEAKER_TX support found");
}
}
else if(device == SND_DEVICE_TTY_FULL) {
new_rx_device = DEVICE_TTY_HEADSET_MONO_RX;
new_tx_device = DEVICE_TTY_HEADSET_MONO_TX;
ALOGV("In TTY_FULL");
}
else if(device == SND_DEVICE_TTY_VCO) {
new_rx_device = DEVICE_TTY_HEADSET_MONO_RX;
new_tx_device = DEVICE_HANDSET_TX;
ALOGV("In TTY_VCO");
}
else if(device == SND_DEVICE_TTY_HCO) {
new_rx_device = DEVICE_HANDSET_RX;
new_tx_device = DEVICE_TTY_HEADSET_MONO_TX;
ALOGV("In TTY_HCO");
}
#ifdef HTC_ACOUSTIC_AUDIO
else if((device == SND_DEVICE_BT) ||
(device == SND_DEVICE_BT_EC_OFF)) {
#else
else if(device == SND_DEVICE_BT) {
#endif
new_rx_device = DEVICE_BT_SCO_RX;
new_tx_device = DEVICE_BT_SCO_TX;
ALOGV("In BT_HCO");
}
else if(device == SND_DEVICE_HEADSET_AND_SPEAKER) {
new_rx_device = DEVICE_SPEAKER_HEADSET_RX;
new_tx_device = DEVICE_HEADSET_TX;
ALOGV("In DEVICE_SPEAKER_HEADSET_RX and DEVICE_HEADSET_TX");
if(DEV_ID(new_rx_device) == INVALID_DEVICE) {
new_rx_device = DEVICE_HEADSET_RX;
ALOGV("Falling back to HEADSET_RX AND HEADSET_TX as no combo device support found");
}
}
else if(device == SND_DEVICE_HEADPHONE_AND_SPEAKER) {
new_rx_device = DEVICE_SPEAKER_HEADSET_RX;
new_tx_device = DEVICE_HANDSET_TX;
ALOGV("In DEVICE_SPEAKER_HEADSET_RX and DEVICE_HANDSET_TX");
if(DEV_ID(new_rx_device) == INVALID_DEVICE) {
new_rx_device = DEVICE_HEADSET_RX;
ALOGV("Falling back to HEADSET_RX AND HANDSET_TX as no combo device support found");
}
}
else if (device == SND_DEVICE_HDMI) {
new_rx_device = DEVICE_HDMI_STERO_RX;
new_tx_device = cur_tx;
ALOGI("In DEVICE_HDMI_STERO_RX and cur_tx");
}
#ifdef QCOM_ANC_HEADSET_ENABLED
else if(device == SND_DEVICE_ANC_HEADSET) {
new_rx_device = DEVICE_ANC_HEADSET_STEREO_RX;
new_tx_device = DEVICE_HEADSET_TX;
ALOGI("In ANC HEADSET");
}
else if(device == SND_DEVICE_NO_MIC_ANC_HEADSET) {
new_rx_device = DEVICE_ANC_HEADSET_STEREO_RX;
new_tx_device = DEVICE_HANDSET_TX;
ALOGI("In ANC HEADPhone");
}
#endif
#ifdef QCOM_FM_ENABLED
else if(device == SND_DEVICE_FM_TX){
new_rx_device = DEVICE_FMRADIO_STEREO_RX;
ALOGI("In DEVICE_FMRADIO_STEREO_RX and cur_tx");
}
#endif
else if(device == SND_DEVICE_SPEAKER_TX) {
new_rx_device = cur_rx;
new_tx_device = DEVICE_SPEAKER_TX;
ALOGI("In SPEAKER_TX cur_rx = %d\n", cur_rx);
}
#ifdef SAMSUNG_AUDIO
#if 0
else if (device == SND_DEVICE_VOIP_HANDSET) {
new_rx_device = DEVICE_HANDSET_VOIP_RX;
new_tx_device = DEVICE_HANDSET_VOIP_TX;
ALOGD("In VOIP HANDSET");
}
else if (device == SND_DEVICE_VOIP_SPEAKER) {
new_rx_device = DEVICE_SPEAKER_VOIP_RX;
new_tx_device = DEVICE_SPEAKER_VOIP_TX;
ALOGD("In VOIP SPEAKER");
}
else if (device == SND_DEVICE_VOIP_HEADSET) {
new_rx_device = DEVICE_HEADSET_VOIP_RX;
new_tx_device = DEVICE_HEADSET_VOIP_TX;
ALOGD("In VOIP HEADSET");
}
#endif
else if (device == SND_DEVICE_CALL_HANDSET) {
new_rx_device = DEVICE_HANDSET_CALL_RX;
new_tx_device = DEVICE_HANDSET_CALL_TX;
ALOGD("In CALL HANDSET");
}
else if (device == SND_DEVICE_CALL_SPEAKER) {
new_rx_device = DEVICE_SPEAKER_CALL_RX;
new_tx_device = DEVICE_SPEAKER_CALL_TX;
ALOGD("In CALL SPEAKER");
}
else if (device == SND_DEVICE_CALL_HEADSET) {
new_rx_device = DEVICE_HEADSET_CALL_RX;
new_tx_device = DEVICE_HEADSET_CALL_TX;
ALOGD("In CALL HEADSET");
}
else if(device == SND_DEVICE_VR_SPEAKER) {
new_rx_device = DEVICE_SPEAKER_RX;
new_tx_device = DEVICE_SPEAKER_VR_TX;
ALOGV("In VR SPEAKER");
}
else if(device == SND_DEVICE_VR_HEADSET) {
new_rx_device = DEVICE_HEADSET_RX;
new_tx_device = DEVICE_HEADSET_VR_TX;
ALOGV("In VR HEADSET");
}
#endif
#ifdef BACK_MIC_CAMCORDER
else if (device == SND_DEVICE_BACK_MIC_CAMCORDER) {
new_rx_device = cur_rx;
new_tx_device = DEVICE_CAMCORDER_TX;
ALOGV("In BACK_MIC_CAMCORDER");
}
#endif
if(new_rx_device != INVALID_DEVICE)
ALOGD("new_rx = %d", DEV_ID(new_rx_device));
if(new_tx_device != INVALID_DEVICE)
ALOGD("new_tx = %d", DEV_ID(new_tx_device));
if ((mode == AudioSystem::MODE_IN_CALL) && !isStreamOn(VOICE_CALL)) {
#ifdef LEGACY_QCOM_VOICE
msm_start_voice();
#endif
ALOGV("Going to enable RX/TX device for voice stream");
// Routing Voice
if ( (new_rx_device != INVALID_DEVICE) && (new_tx_device != INVALID_DEVICE))
{
#ifdef QCOM_ACDB_ENABLED
initACDB();
acdb_loader_send_voice_cal(ACDB_ID(new_rx_device),ACDB_ID(new_tx_device));
#endif
ALOGD("Starting voice on Rx %d and Tx %d device", DEV_ID(new_rx_device), DEV_ID(new_tx_device));
msm_route_voice(DEV_ID(new_rx_device),DEV_ID(new_tx_device), 1);
}
else
{
return -1;
}
if(cur_rx != INVALID_DEVICE && (enableDevice(cur_rx,0) == -1))
return -1;
if(cur_tx != INVALID_DEVICE&&(enableDevice(cur_tx,0) == -1))
return -1;
//Enable RX device
if(new_rx_device !=INVALID_DEVICE && (enableDevice(new_rx_device,1) == -1))
return -1;
//Enable TX device
if(new_tx_device !=INVALID_DEVICE && (enableDevice(new_tx_device,1) == -1))
return -1;
#ifdef LEGACY_QCOM_VOICE
msm_set_voice_tx_mute(0);
#else
voice_session_id = msm_get_voc_session(VOICE_SESSION_NAME);
if(voice_session_id <=0) {
ALOGE("voice session invalid");
return 0;
}
msm_start_voice_ext(voice_session_id);
msm_set_voice_tx_mute_ext(voice_session_mute,voice_session_id);
#endif
if(!isDeviceListEmpty())
updateDeviceInfo(new_rx_device,new_tx_device);
cur_rx = new_rx_device;
cur_tx = new_tx_device;
addToTable(0,cur_rx,cur_tx,VOICE_CALL,true);
}
else if ((mode == AudioSystem::MODE_NORMAL) && isStreamOnAndActive(VOICE_CALL)) {
ALOGV("Going to disable RX/TX device during end of voice call");
temp = getNodeByStreamType(VOICE_CALL);
if(temp == NULL)
return 0;
// Ending voice call
ALOGD("Ending Voice call");
#ifdef LEGACY_QCOM_VOICE
msm_end_voice();
#else
msm_end_voice_ext(voice_session_id);
voice_session_id = 0;
voice_session_mute = 0;
#endif
if((temp->dev_id != INVALID_DEVICE && temp->dev_id_tx != INVALID_DEVICE)
#ifdef QCOM_VOIP_ENABLED
&& (!isStreamOn(VOIP_CALL))
#endif
) {
enableDevice(temp->dev_id,0);
enableDevice(temp->dev_id_tx,0);
}
deleteFromTable(VOICE_CALL);
updateDeviceInfo(new_rx_device,new_tx_device);
if(new_rx_device != INVALID_DEVICE && new_tx_device != INVALID_DEVICE) {
cur_rx = new_rx_device;
cur_tx = new_tx_device;
}
}
else {
ALOGD("updateDeviceInfo() called for default case");
updateDeviceInfo(new_rx_device,new_tx_device);
}
#ifdef HTC_ACOUSTIC_AUDIO
if (support_tpa2051)
do_tpa2051_control(mode ^1);
#endif
return NO_ERROR;
}
// always call with mutex held
status_t AudioHardware::doAudioRouteOrMute(uint32_t device)
{
// BT acoustics is not supported. This might be used by OEMs. Hence commenting
// the code and not removing it.
#if 0
if (device == (uint32_t)SND_DEVICE_BT || device == (uint32_t)SND_DEVICE_CARKIT) {
if (mBluetoothId) {
device = mBluetoothId;
} else if (!mBluetoothNrec) {
device = SND_DEVICE_BT_EC_OFF;
}
}
#endif
#ifdef HTC_ACOUSTIC_AUDIO
if (device == SND_DEVICE_BT) {
if (!mBluetoothNrec)
device = SND_DEVICE_BT_EC_OFF;
}
if (support_aic3254) {
aic3254_config(device);
do_aic3254_control(device);
}
getACDB(device);
#endif
if (isStreamOnAndActive(VOICE_CALL) && mMicMute == false)
msm_set_voice_tx_mute(0);
#ifdef HTC_ACOUSTIC_AUDIO
if (isInCall())
setVoiceVolume(mVoiceVolume);
#endif
ALOGV("doAudioRouteOrMute() device %x, mMode %d, mMicMute %d", device, mMode, mMicMute);
return do_route_audio_rpc(device, mMode, mMicMute);
}
#ifdef HTC_ACOUSTIC_AUDIO
status_t AudioHardware::set_mRecordState(bool onoff) {
mRecordState = onoff;
return 0;
}
status_t AudioHardware::get_mRecordState(void) {
return mRecordState;
}
status_t AudioHardware::get_snd_dev(void) {
return mCurSndDevice;
}
void AudioHardware::getACDB(uint32_t device) {
rx_htc_acdb = 0;
tx_htc_acdb = 0;
if (device == SND_DEVICE_BT) {
if (mBluetoothIdTx != 0) {
rx_htc_acdb = mBluetoothIdRx;
tx_htc_acdb = mBluetoothIdTx;
} else {
/* use default BT entry defined in AudioBTID.csv */
rx_htc_acdb = mBTEndpoints[0].rx;
tx_htc_acdb = mBTEndpoints[0].tx;
}
} else if (device == SND_DEVICE_CARKIT ||
device == SND_DEVICE_BT_EC_OFF) {
if (mBluetoothIdTx != 0) {
rx_htc_acdb = mBluetoothIdRx;
tx_htc_acdb = mBluetoothIdTx;
} else {
/* use default carkit entry defined in AudioBTID.csv */
rx_htc_acdb = mBTEndpoints[1].rx;
tx_htc_acdb = mBTEndpoints[1].tx;
}
}
ALOGV("getACDB: device = %d, HTC RX ACDB ID = %d, HTC TX ACDB ID = %d",
device, rx_htc_acdb, tx_htc_acdb);
}
status_t AudioHardware::do_aic3254_control(uint32_t device) {
ALOGD("do_aic3254_control device: %d mode: %d record: %d", device, mMode, mRecordState);
uint32_t new_aic_txmode = UPLINK_OFF;
uint32_t new_aic_rxmode = DOWNLINK_OFF;
Mutex::Autolock lock(mAIC3254ConfigLock);
if (isInCall()) {
switch (device) {
case SND_DEVICE_HEADSET:
new_aic_rxmode = CALL_DOWNLINK_EMIC_HEADSET;
new_aic_txmode = CALL_UPLINK_EMIC_HEADSET;
break;
case SND_DEVICE_SPEAKER:
case SND_DEVICE_SPEAKER_BACK_MIC:
new_aic_rxmode = CALL_DOWNLINK_IMIC_SPEAKER;
new_aic_txmode = CALL_UPLINK_IMIC_SPEAKER;
break;
case SND_DEVICE_HEADSET_AND_SPEAKER:
case SND_DEVICE_HEADSET_AND_SPEAKER_BACK_MIC:
new_aic_rxmode = RING_HEADSET_SPEAKER;
break;
case SND_DEVICE_NO_MIC_HEADSET:
case SND_DEVICE_NO_MIC_HEADSET_BACK_MIC:
new_aic_rxmode = CALL_DOWNLINK_IMIC_HEADSET;
new_aic_txmode = CALL_UPLINK_IMIC_HEADSET;
break;
case SND_DEVICE_HANDSET:
case SND_DEVICE_HANDSET_BACK_MIC:
new_aic_rxmode = CALL_DOWNLINK_IMIC_RECEIVER;
new_aic_txmode = CALL_UPLINK_IMIC_RECEIVER;
break;
default:
break;
}
} else {
#ifdef QCOM_TUNNEL_LPA_ENABLED
if (checkOutputStandby() && !isStreamOnAndActive(LPA_DECODE)) {
#else
if (checkOutputStandby()) {
#endif
if (device == SND_DEVICE_FM_HEADSET) {
new_aic_rxmode = FM_OUT_HEADSET;
new_aic_txmode = FM_IN_HEADSET;
} else if (device == SND_DEVICE_FM_SPEAKER) {
new_aic_rxmode = FM_OUT_SPEAKER;
new_aic_txmode = FM_IN_SPEAKER;
}
} else {
switch (device) {
case SND_DEVICE_HEADSET_AND_SPEAKER:
case SND_DEVICE_HEADSET_AND_SPEAKER_BACK_MIC:
case SND_DEVICE_HEADPHONE_AND_SPEAKER:
new_aic_rxmode = RING_HEADSET_SPEAKER;
break;
case SND_DEVICE_SPEAKER:
case SND_DEVICE_SPEAKER_BACK_MIC:
new_aic_rxmode = PLAYBACK_SPEAKER;
break;
case SND_DEVICE_HANDSET:
case SND_DEVICE_HANDSET_BACK_MIC:
new_aic_rxmode = PLAYBACK_RECEIVER;
break;
case SND_DEVICE_HEADSET:
case SND_DEVICE_NO_MIC_HEADSET:
case SND_DEVICE_NO_MIC_HEADSET_BACK_MIC:
new_aic_rxmode = PLAYBACK_HEADSET;
break;
default:
break;
}
}
if (mRecordState) {
switch (device) {
case SND_DEVICE_HEADSET:
new_aic_txmode = VOICERECORD_EMIC;
break;
case SND_DEVICE_HANDSET_BACK_MIC:
case SND_DEVICE_SPEAKER_BACK_MIC:
case SND_DEVICE_NO_MIC_HEADSET_BACK_MIC:
case SND_DEVICE_HEADSET_AND_SPEAKER_BACK_MIC:
new_aic_txmode = VIDEORECORD_IMIC;
break;
case SND_DEVICE_HANDSET:
case SND_DEVICE_SPEAKER:
case SND_DEVICE_NO_MIC_HEADSET:
case SND_DEVICE_HEADSET_AND_SPEAKER:
new_aic_txmode = VOICERECORD_IMIC;
break;
default:
break;
}
}
}
if (new_aic_rxmode != cur_aic_rx)
ALOGD("do_aic3254_control: set aic3254 rx to %d", new_aic_rxmode);
if (aic3254_ioctl(AIC3254_CONFIG_RX, new_aic_rxmode) >= 0)
cur_aic_rx = new_aic_rxmode;
if (new_aic_txmode != cur_aic_tx)
ALOGD("do_aic3254_control: set aic3254 tx to %d", new_aic_txmode);
if (aic3254_ioctl(AIC3254_CONFIG_TX, new_aic_txmode) >= 0)
cur_aic_tx = new_aic_txmode;
if (cur_aic_tx == UPLINK_OFF && cur_aic_rx == DOWNLINK_OFF && aic3254_enabled) {
strcpy(mCurDspProfile, "\0");
aic3254_enabled = false;
aic3254_powerdown();
} else if (cur_aic_tx != UPLINK_OFF || cur_aic_rx != DOWNLINK_OFF)
aic3254_enabled = true;
return NO_ERROR;
}
bool AudioHardware::isAic3254Device(uint32_t device) {
switch(device) {
case SND_DEVICE_HANDSET:
case SND_DEVICE_SPEAKER:
case SND_DEVICE_HEADSET:
case SND_DEVICE_NO_MIC_HEADSET:
case SND_DEVICE_FM_HEADSET:
case SND_DEVICE_HEADSET_AND_SPEAKER:
case SND_DEVICE_FM_SPEAKER:
case SND_DEVICE_HEADPHONE_AND_SPEAKER:
case SND_DEVICE_HANDSET_BACK_MIC:
case SND_DEVICE_SPEAKER_BACK_MIC:
case SND_DEVICE_NO_MIC_HEADSET_BACK_MIC:
case SND_DEVICE_HEADSET_AND_SPEAKER_BACK_MIC:
return true;
break;
default:
return false;
break;
}
}
status_t AudioHardware::aic3254_config(uint32_t device) {
ALOGD("aic3254_config: device %d enabled %d", device, aic3254_enabled);
char name[22] = "\0";
char aap[9] = "\0";
if ((!isAic3254Device(device) ||
!aic3254_enabled) &&
strlen(mCurDspProfile) != 0)
return NO_ERROR;
Mutex::Autolock lock(mAIC3254ConfigLock);
if (mMode == AudioSystem::MODE_IN_CALL) {
strcpy(name, "Phone_Default");
switch (device) {
case SND_DEVICE_HANDSET:
case SND_DEVICE_HANDSET_BACK_MIC:
strcpy(name, "Phone_Handset_Dualmic");
break;
case SND_DEVICE_HEADSET:
case SND_DEVICE_HEADSET_AND_SPEAKER:
case SND_DEVICE_HEADSET_AND_SPEAKER_BACK_MIC:
case SND_DEVICE_NO_MIC_HEADSET:
strcpy(name, "Phone_Headset");
break;
case SND_DEVICE_SPEAKER:
strcpy(name, "Phone_Speaker_Dualmic");
break;
default:
break;
}
} else {
if ((strcasecmp(mActiveAP, "Camcorder") == 0)) {
if (strlen(mEffect) != 0) {
strcpy(name, "Recording_");
strcat(name, mEffect);
} else
strcpy(name, "Playback_Default");
} else if (mRecordState) {
strcpy(name, "Record_Default");
} else if (strlen(mEffect) == 0 && !mEffectEnabled)
strcpy(name, "Playback_Default");
else {
if (mEffectEnabled)
strcpy(name, mEffect);
if ((strcasecmp(name, "Srs") == 0) ||
(strcasecmp(name, "Dolby") == 0)) {
strcpy(mEffect, name);
if (strcasecmp(mActiveAP, "Music") == 0)
strcat(name, "_a");
else if (strcasecmp(mActiveAP, "Video") == 0)
strcat(name, "_v");
if (device == SND_DEVICE_SPEAKER)
strcat(name, "_spk");
else
strcat(name, "_hp");
}
}
}
if (strcasecmp(mCurDspProfile, name)) {
ALOGD("aic3254_config: loading effect %s", name);
strcpy(mCurDspProfile, name);
} else {
ALOGD("aic3254_config: effect %s already loaded", name);
return NO_ERROR;
}
int rc = set_sound_effect(name);
if (rc < 0) {
ALOGE("Could not set sound effect %s: %d", name, rc);
return rc;
}
return NO_ERROR;
}
int AudioHardware::aic3254_ioctl(int cmd, const int argc) {
int rc = -1;
int (*set_aic3254_ioctl)(int, const int*);
set_aic3254_ioctl = (int (*)(int, const int*))::dlsym(acoustic, "set_aic3254_ioctl");
if ((*set_aic3254_ioctl) == 0) {
ALOGE("Could not open set_aic3254_ioctl()");
return rc;
}
rc = set_aic3254_ioctl(cmd, &argc);
if (rc < 0)
ALOGE("aic3254_ioctl failed");
return rc;
}
void AudioHardware::aic3254_powerdown() {
int rc = aic3254_ioctl(AIC3254_POWERDOWN, 0);
if (rc < 0)
ALOGE("aic3254_powerdown failed");
else
ALOGI("aic3254 powered off");
}
#endif
status_t AudioHardware::doRouting(AudioStreamInMSM8x60 *input)
{
Mutex::Autolock lock(mLock);
uint32_t outputDevices = mOutput->devices();
status_t ret = NO_ERROR;
int audProcess = (ADRC_DISABLE | EQ_DISABLE | RX_IIR_DISABLE);
int sndDevice = -1;
if (input != NULL) {
uint32_t inputDevice = input->devices();
ALOGI("do input routing device %x\n", inputDevice);
// ignore routing device information when we start a recording in voice
// call
// Recording will happen through currently active tx device
if((inputDevice == AudioSystem::DEVICE_IN_VOICE_CALL)
#ifdef QCOM_FM_ENABLED
|| (inputDevice == AudioSystem::DEVICE_IN_FM_RX)
|| (inputDevice == AudioSystem::DEVICE_IN_FM_RX_A2DP)
#endif
)
return NO_ERROR;
if (inputDevice != 0) {
if (inputDevice & AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET) {
ALOGI("Routing audio to Bluetooth PCM\n");
sndDevice = SND_DEVICE_BT;
#ifdef BACK_MIC_CAMCORDER
} else if (inputDevice & AudioSystem::DEVICE_IN_BACK_MIC) {
ALOGI("Routing audio to back mic (camcorder)");
sndDevice = SND_DEVICE_BACK_MIC_CAMCORDER;
#endif
} else if (inputDevice & AudioSystem::DEVICE_IN_WIRED_HEADSET) {
if ((outputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADSET) &&
(outputDevices & AudioSystem::DEVICE_OUT_SPEAKER)) {
ALOGI("Routing audio to Wired Headset and Speaker\n");
sndDevice = SND_DEVICE_HEADSET_AND_SPEAKER;
audProcess = (ADRC_ENABLE | EQ_ENABLE | RX_IIR_ENABLE | MBADRC_ENABLE);
} else {
ALOGI("Routing audio to Wired Headset\n");
sndDevice = SND_DEVICE_HEADSET;
}
}
#ifdef QCOM_ANC_HEADSET_ENABLED
else if (inputDevice & AudioSystem::DEVICE_IN_ANC_HEADSET) {
ALOGI("Routing audio to ANC Headset\n");
sndDevice = SND_DEVICE_ANC_HEADSET;
}
#endif
else if (isStreamOnAndActive(PCM_PLAY)
#ifdef QCOM_TUNNEL_LPA_ENABLED
|| isStreamOnAndActive(LPA_DECODE)
#endif
) {
if (outputDevices & AudioSystem::DEVICE_OUT_EARPIECE) {
ALOGI("Routing audio to Handset\n");
sndDevice = SND_DEVICE_HANDSET;
} else if (outputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADPHONE) {
ALOGI("Routing audio to Speakerphone\n");
sndDevice = SND_DEVICE_NO_MIC_HEADSET;
}
#ifdef QCOM_FM_ENABLED
else if (outputDevices & AudioSystem::DEVICE_OUT_FM_TX) {
ALOGE("Routing audio_rx to Speaker\n");
sndDevice = SND_DEVICE_SPEAKER_TX;
}
#endif
else {
ALOGI("Routing audio to Speaker\n");
sndDevice = SND_DEVICE_SPEAKER;
}
} else {
ALOGI("Routing audio to Speaker (default)\n");
sndDevice = SND_DEVICE_SPEAKER;
}
#ifdef SAMSUNG_AUDIO
if (input->isForVR()) {
if (sndDevice == SND_DEVICE_SPEAKER)
sndDevice = SND_DEVICE_VR_SPEAKER;
else if (sndDevice == SND_DEVICE_HEADSET)
sndDevice = SND_DEVICE_VR_HEADSET;
}
#endif
}
// if inputDevice == 0, restore output routing
}
if (sndDevice == -1) {
if (outputDevices & (outputDevices - 1)) {
if ((outputDevices & AudioSystem::DEVICE_OUT_SPEAKER) == 0) {
ALOGW("Hardware does not support requested route combination (%#X),"
" picking closest possible route...", outputDevices);
}
}
if ((mTtyMode != TTY_OFF) && (mMode == AudioSystem::MODE_IN_CALL) &&
((outputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADSET)
#ifdef QCOM_ANC_HEADSET_ENABLED
||(outputDevices & AudioSystem::DEVICE_OUT_ANC_HEADSET)
#endif
)) {
if (mTtyMode == TTY_FULL) {
ALOGI("Routing audio to TTY FULL Mode\n");
sndDevice = SND_DEVICE_TTY_FULL;
} else if (mTtyMode == TTY_VCO) {
ALOGI("Routing audio to TTY VCO Mode\n");
sndDevice = SND_DEVICE_TTY_VCO;
} else if (mTtyMode == TTY_HCO) {
ALOGI("Routing audio to TTY HCO Mode\n");
sndDevice = SND_DEVICE_TTY_HCO;
}
} else if (outputDevices &
(AudioSystem::DEVICE_OUT_BLUETOOTH_SCO | AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET)) {
ALOGI("Routing audio to Bluetooth PCM\n");
sndDevice = SND_DEVICE_BT;
} else if (outputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT) {
ALOGI("Routing audio to Bluetooth PCM\n");
sndDevice = SND_DEVICE_CARKIT;
} else if (outputDevices & AudioSystem::DEVICE_OUT_AUX_DIGITAL) {
ALOGI("Routing audio to HDMI\n");
sndDevice = SND_DEVICE_HDMI;
} else if ((outputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADSET) &&
(outputDevices & AudioSystem::DEVICE_OUT_SPEAKER)) {
ALOGI("Routing audio to Wired Headset and Speaker\n");
sndDevice = SND_DEVICE_HEADSET_AND_SPEAKER;
audProcess = (ADRC_ENABLE | EQ_ENABLE | RX_IIR_ENABLE | MBADRC_ENABLE);
} else
#ifdef QCOM_FM_ENABLED
if ((outputDevices & AudioSystem::DEVICE_OUT_FM_TX) &&
(outputDevices & AudioSystem::DEVICE_OUT_SPEAKER)) {
ALOGI("Routing audio to FM Tx and Speaker\n");
sndDevice = SND_DEVICE_FM_TX_AND_SPEAKER;
enableComboDevice(sndDevice,1);
audProcess = (ADRC_ENABLE | EQ_ENABLE | RX_IIR_ENABLE | MBADRC_ENABLE);
} else
#endif
if (outputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADPHONE) {
if (outputDevices & AudioSystem::DEVICE_OUT_SPEAKER) {
ALOGI("Routing audio to No microphone Wired Headset and Speaker (%d,%x)\n", mMode, outputDevices);
sndDevice = SND_DEVICE_HEADPHONE_AND_SPEAKER;
audProcess = (ADRC_ENABLE | EQ_ENABLE | RX_IIR_ENABLE | MBADRC_ENABLE);
} else {
ALOGI("Routing audio to No microphone Wired Headset (%d,%x)\n", mMode, outputDevices);
sndDevice = SND_DEVICE_NO_MIC_HEADSET;
audProcess = (ADRC_ENABLE | EQ_ENABLE | RX_IIR_ENABLE | MBADRC_ENABLE);
}
}
#ifdef QCOM_ANC_HEADSET_ENABLED
else if (outputDevices & AudioSystem::DEVICE_OUT_ANC_HEADPHONE) {
ALOGI("Routing audio to No microphone ANC Headset (%d,%x)\n", mMode, outputDevices);
sndDevice = SND_DEVICE_NO_MIC_ANC_HEADSET;
audProcess = (ADRC_ENABLE | EQ_ENABLE | RX_IIR_ENABLE | MBADRC_ENABLE);
}
#endif
else if (outputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADSET) {
ALOGI("Routing audio to Wired Headset\n");
sndDevice = SND_DEVICE_HEADSET;
audProcess = (ADRC_ENABLE | EQ_ENABLE | RX_IIR_ENABLE | MBADRC_ENABLE);
}
#ifdef QCOM_ANC_HEADSET_ENABLED
else if (outputDevices & AudioSystem::DEVICE_OUT_ANC_HEADSET) {
ALOGI("Routing audio to ANC Headset\n");
sndDevice = SND_DEVICE_ANC_HEADSET;
audProcess = (ADRC_ENABLE | EQ_ENABLE | RX_IIR_ENABLE | MBADRC_ENABLE);
}
#endif
else if (outputDevices & AudioSystem::DEVICE_OUT_SPEAKER) {
ALOGI("Routing audio to Speakerphone\n");
sndDevice = SND_DEVICE_SPEAKER;
audProcess = (ADRC_ENABLE | EQ_ENABLE | RX_IIR_ENABLE | MBADRC_ENABLE);
} else
#ifdef QCOM_FM_ENABLED
if (outputDevices & AudioSystem::DEVICE_OUT_FM_TX){
ALOGI("Routing audio to FM Tx Device\n");
sndDevice = SND_DEVICE_FM_TX;
audProcess = (ADRC_ENABLE | EQ_ENABLE | RX_IIR_ENABLE | MBADRC_ENABLE);
} else
#endif
if(outputDevices & AudioSystem::DEVICE_OUT_EARPIECE){
ALOGI("Routing audio to Handset\n");
sndDevice = SND_DEVICE_HANDSET;
audProcess = (ADRC_ENABLE | EQ_ENABLE | RX_IIR_ENABLE | MBADRC_ENABLE);
}
}
if (dualmic_enabled) {
#ifdef SAMSUNG_AUDIO
if (sndDevice == SND_DEVICE_HANDSET) {
ALOGI("Routing audio to Handset with DualMike enabled\n");
sndDevice = SND_DEVICE_IN_S_SADC_OUT_HANDSET;
}
#else
if (sndDevice == SND_DEVICE_HANDSET) {
ALOGI("Routing audio to Handset with DualMike enabled\n");
sndDevice = SND_DEVICE_IN_S_SADC_OUT_HANDSET;
} else if (sndDevice == SND_DEVICE_SPEAKER) {
ALOGI("Routing audio to Speakerphone with DualMike enabled\n");
sndDevice = SND_DEVICE_IN_S_SADC_OUT_SPEAKER_PHONE;
}
#endif
}
#ifdef SAMSUNG_AUDIO
if (mMode == AudioSystem::MODE_IN_CALL) {
if ((!dualmic_enabled) && (sndDevice == SND_DEVICE_HANDSET)) {
ALOGD("Routing audio to Call Handset\n");
sndDevice = SND_DEVICE_CALL_HANDSET;
} else if (sndDevice == SND_DEVICE_SPEAKER) {
ALOGD("Routing audio to Call Speaker\n");
sndDevice = SND_DEVICE_CALL_SPEAKER;
} else if (sndDevice == SND_DEVICE_HEADSET) {
ALOGD("Routing audio to Call Headset\n");
sndDevice = SND_DEVICE_CALL_HEADSET;
}
#if 0
} else if (mMode == AudioSystem::MODE_IN_COMMUNICATION) {
if (sndDevice == SND_DEVICE_HANDSET) {
ALOGD("Routing audio to VOIP handset\n");
sndDevice = SND_DEVICE_VOIP_HANDSET;
} else if (sndDevice == SND_DEVICE_SPEAKER) {
ALOGD("Routing audio to VOIP speaker\n");
sndDevice = SND_DEVICE_VOIP_SPEAKER;
} else if (sndDevice == SND_DEVICE_HEADSET) {
ALOGD("Routing audio to VOIP headset\n");
sndDevice = SND_DEVICE_VOIP_HEADSET;
}
#endif
}
#endif
#ifdef QCOM_FM_ENABLED
if ((outputDevices & AudioSystem::DEVICE_OUT_FM) && (mFmFd == -1)){
enableFM(sndDevice);
}
if ((mFmFd != -1) && !(outputDevices & AudioSystem::DEVICE_OUT_FM)){
disableFM();
}
if ((CurrentComboDeviceData.DeviceId == INVALID_DEVICE) &&
(sndDevice == SND_DEVICE_FM_TX_AND_SPEAKER )){
/* speaker rx is already enabled change snd device to the fm tx
* device and let the flow take the regular route to
* updatedeviceinfo().
*/
Mutex::Autolock lock_1(mComboDeviceLock);
CurrentComboDeviceData.DeviceId = SND_DEVICE_FM_TX_AND_SPEAKER;
sndDevice = DEVICE_FMRADIO_STEREO_RX;
}
else
#endif
if(CurrentComboDeviceData.DeviceId != INVALID_DEVICE){
/* time to disable the combo device */
enableComboDevice(CurrentComboDeviceData.DeviceId,0);
Mutex::Autolock lock_2(mComboDeviceLock);
CurrentComboDeviceData.DeviceId = INVALID_DEVICE;
CurrentComboDeviceData.StreamType = INVALID_STREAM;
}
if (sndDevice != -1 && sndDevice != mCurSndDevice) {
ret = doAudioRouteOrMute(sndDevice);
mCurSndDevice = sndDevice;
}
#ifdef QCOM_ANC_HEADSET_ENABLED
//check if ANC setting is ON
if (anc_setting == true
&& (sndDevice == SND_DEVICE_ANC_HEADSET
|| sndDevice ==SND_DEVICE_NO_MIC_ANC_HEADSET)) {
enableANC(1,sndDevice);
anc_running = true;
} else {
//disconnection case
anc_running = false;
}
#endif
return ret;
}
status_t AudioHardware::enableComboDevice(uint32_t sndDevice, bool enableOrDisable)
{
ALOGD("enableComboDevice %u",enableOrDisable);
status_t status = NO_ERROR;
#ifdef QCOM_TUNNEL_LPA_ENABLED
Routing_table *LpaNode = getNodeByStreamType(LPA_DECODE);
#endif
Routing_table *PcmNode = getNodeByStreamType(PCM_PLAY);
if(enableDevice(DEVICE_SPEAKER_RX, enableOrDisable)) {
ALOGE("enableDevice failed for device %d", DEVICE_SPEAKER_RX);
return -1;
}
#ifdef QCOM_FM_ENABLED
if(SND_DEVICE_FM_TX_AND_SPEAKER == sndDevice){
if(getNodeByStreamType(VOICE_CALL) || getNodeByStreamType(FM_RADIO) ||
getNodeByStreamType(FM_A2DP)){
ALOGE("voicecall/FM radio active bailing out");
return NO_ERROR;
}
if(
#ifdef QCOM_TUNNEL_LPA_ENABLED
!LpaNode &&
#endif
!PcmNode) {
ALOGE("No active playback session active bailing out ");
cur_rx = DEVICE_FMRADIO_STEREO_RX;
return NO_ERROR;
}
Mutex::Autolock lock_1(mComboDeviceLock);
Routing_table* temp = NULL;
if (enableOrDisable == 1) {
if(CurrentComboDeviceData.StreamType == INVALID_STREAM){
if (PcmNode){
temp = PcmNode;
CurrentComboDeviceData.StreamType = PCM_PLAY;
ALOGD("PCM_PLAY session Active ");
#ifdef QCOM_TUNNEL_LPA_ENABLED
}else if(LpaNode){
temp = LpaNode;
CurrentComboDeviceData.StreamType = LPA_DECODE;
ALOGD("LPA_DECODE session Active ");
#endif
} else {
ALOGE("no PLAYback session Active ");
return -1;
}
}else
temp = getNodeByStreamType(CurrentComboDeviceData.StreamType);
if(temp == NULL){
ALOGE("speaker de-route not possible");
return -1;
}
ALOGD("combo:msm_route_stream(%d,%d,1)",temp->dec_id,
DEV_ID(DEVICE_SPEAKER_RX));
if(msm_route_stream(PCM_PLAY, temp->dec_id, DEV_ID(DEVICE_SPEAKER_RX),
1)) {
ALOGE("msm_route_stream failed");
return -1;
}
}else if(enableOrDisable == 0) {
temp = getNodeByStreamType(CurrentComboDeviceData.StreamType);
if(temp == NULL){
ALOGE("speaker de-route not possible");
return -1;
}
ALOGD("combo:de-route msm_route_stream(%d,%d,0)",temp->dec_id,
DEV_ID(DEVICE_SPEAKER_RX));
if(msm_route_stream(PCM_PLAY, temp->dec_id,
DEV_ID(DEVICE_SPEAKER_RX), 0)) {
ALOGE("msm_route_stream failed");
return -1;
}
}
}
#endif
return status;
}
#ifdef QCOM_FM_ENABLED
status_t AudioHardware::enableFM(int sndDevice)
{
ALOGD("enableFM");
status_t status = NO_INIT;
unsigned short session_id = INVALID_DEVICE;
status = ::open(FM_DEVICE, O_RDWR);
if (status < 0) {
ALOGE("Cannot open FM_DEVICE errno: %d", errno);
goto Error;
}
mFmFd = status;
if(ioctl(mFmFd, AUDIO_GET_SESSION_ID, &session_id)) {
ALOGE("AUDIO_GET_SESSION_ID failed*********");
goto Error;
}
if(enableDevice(DEVICE_FMRADIO_STEREO_TX, 1)) {
ALOGE("enableDevice failed for device %d", DEVICE_FMRADIO_STEREO_TX);
goto Error;
}
#ifdef QCOM_ACDB_ENABLED
acdb_loader_send_audio_cal(ACDB_ID(DEVICE_FMRADIO_STEREO_TX),
CAPABILITY(DEVICE_FMRADIO_STEREO_TX));
#endif
if(msm_route_stream(PCM_PLAY, session_id, DEV_ID(DEVICE_FMRADIO_STEREO_TX), 1)) {
ALOGE("msm_route_stream failed");
goto Error;
}
addToTable(session_id,cur_rx,INVALID_DEVICE,FM_RADIO,true);
if(sndDevice == mCurSndDevice || mCurSndDevice == -1) {
enableDevice(cur_rx, 1);
#ifdef QCOM_ACDB_ENABLED
acdb_loader_send_audio_cal(ACDB_ID(cur_rx), CAPABILITY(cur_rx));
#endif
msm_route_stream(PCM_PLAY,session_id,DEV_ID(cur_rx),1);
}
status = ioctl(mFmFd, AUDIO_START, 0);
if (status < 0) {
ALOGE("Cannot do AUDIO_START");
goto Error;
}
return NO_ERROR;
Error:
if (mFmFd >= 0) {
::close(mFmFd);
mFmFd = -1;
}
return NO_ERROR;
}
status_t AudioHardware::disableFM()
{
ALOGD("disableFM");
Routing_table* temp = NULL;
temp = getNodeByStreamType(FM_RADIO);
if(temp == NULL)
return 0;
if (mFmFd >= 0) {
::close(mFmFd);
mFmFd = -1;
}
if(msm_route_stream(PCM_PLAY, temp->dec_id, DEV_ID(DEVICE_FMRADIO_STEREO_TX), 0)) {
ALOGE("msm_route_stream failed");
return 0;
}
if(!getNodeByStreamType(FM_A2DP)) {
if(enableDevice(DEVICE_FMRADIO_STEREO_TX, 0)) {
ALOGE("Device disable failed for device %d", DEVICE_FMRADIO_STEREO_TX);
}
}
deleteFromTable(FM_RADIO);
if(!getNodeByStreamType(VOICE_CALL)
#ifdef QCOM_TUNNEL_LPA_ENABLED
&& !getNodeByStreamType(LPA_DECODE)
#endif
&& !getNodeByStreamType(PCM_PLAY)
#ifdef QCOM_VOIP_ENABLED
&& !getNodeByStreamType(VOIP_CALL)
#endif
) {
if(enableDevice(cur_rx, 0)) {
ALOGV("Disable device[%d] failed errno = %d",DEV_ID(cur_rx),errno);
return 0;
}
}
return NO_ERROR;
}
#endif
status_t AudioHardware::dumpInternals(int fd, const Vector<String16>& args)
{
const size_t SIZE = 256;
char buffer[SIZE];
String8 result;
result.append("AudioHardware::dumpInternals\n");
snprintf(buffer, SIZE, "\tmInit: %s\n", mInit? "true": "false");
result.append(buffer);
snprintf(buffer, SIZE, "\tmMicMute: %s\n", mMicMute? "true": "false");
result.append(buffer);
snprintf(buffer, SIZE, "\tmBluetoothNrec: %s\n", mBluetoothNrec? "true": "false");
result.append(buffer);
snprintf(buffer, SIZE, "\tmBluetoothId: %d\n", mBluetoothId);
result.append(buffer);
::write(fd, result.string(), result.size());
return NO_ERROR;
}
status_t AudioHardware::dump(int fd, const Vector<String16>& args)
{
dumpInternals(fd, args);
for (size_t index = 0; index < mInputs.size(); index++) {
mInputs[index]->dump(fd, args);
}
if (mOutput) {
mOutput->dump(fd, args);
}
return NO_ERROR;
}
uint32_t AudioHardware::getInputSampleRate(uint32_t sampleRate)
{
uint32_t i;
uint32_t prevDelta;
uint32_t delta;
for (i = 0, prevDelta = 0xFFFFFFFF; i < sizeof(inputSamplingRates)/sizeof(uint32_t); i++, prevDelta = delta) {
delta = abs(sampleRate - inputSamplingRates[i]);
if (delta > prevDelta) break;
}
// i is always > 0 here
return inputSamplingRates[i-1];
}
// ----------------------------------------------------------------------------
AudioHardware::AudioStreamOutMSM8x60::AudioStreamOutMSM8x60() :
mHardware(0), mFd(-1), mStartCount(0), mRetryCount(0), mStandby(true), mDevices(0)
{
}
status_t AudioHardware::AudioStreamOutMSM8x60::set(
AudioHardware* hw, uint32_t devices, int *pFormat, uint32_t *pChannels, uint32_t *pRate)
{
int lFormat = pFormat ? *pFormat : 0;
uint32_t lChannels = pChannels ? *pChannels : 0;
uint32_t lRate = pRate ? *pRate : 0;
mHardware = hw;