You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
device_samsung_sm7125-common/audio/impl/ParametersUtil.cpp

406 lines
14 KiB

/*
* Copyright (C) 2018 The Android Open Source Project
*
* 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 "core/default/ParametersUtil.h"
#include "core/default/Util.h"
#include <system/audio.h>
#include <util/CoreUtils.h>
#include <tinyalsa/asoundlib.h>
#include <cutils/properties.h>
namespace android {
namespace hardware {
namespace audio {
namespace CORE_TYPES_CPP_VERSION {
namespace implementation {
/** Converts a status_t in Result according to the rules of AudioParameter::get*
* Note: Static method and not private method to avoid leaking status_t dependency
*/
static Result getHalStatusToResult(status_t status) {
switch (status) {
case OK:
return Result::OK;
case BAD_VALUE: // Nothing was returned, probably because the HAL does
// not handle it
return Result::NOT_SUPPORTED;
case INVALID_OPERATION: // Conversion from string to the requested type
// failed
return Result::INVALID_ARGUMENTS;
default: // Should not happen
ALOGW("Unexpected status returned by getParam: %u", status);
return Result::INVALID_ARGUMENTS;
}
}
Result ParametersUtil::getParam(const char* name, bool* value) {
String8 halValue;
Result retval = getParam(name, &halValue);
*value = false;
if (retval == Result::OK) {
if (halValue.empty()) {
return Result::NOT_SUPPORTED;
}
*value = !(halValue == AudioParameter::valueOff);
}
return retval;
}
Result ParametersUtil::getParam(const char* name, int* value) {
const String8 halName(name);
AudioParameter keys;
keys.addKey(halName);
std::unique_ptr<AudioParameter> params = getParams(keys);
return getHalStatusToResult(params->getInt(halName, *value));
}
Result ParametersUtil::getParam(const char* name, String8* value, AudioParameter context) {
const String8 halName(name);
context.addKey(halName);
std::unique_ptr<AudioParameter> params = getParams(context);
return getHalStatusToResult(params->get(halName, *value));
}
void ParametersUtil::getParametersImpl(
const hidl_vec<ParameterValue>& context, const hidl_vec<hidl_string>& keys,
std::function<void(Result retval, const hidl_vec<ParameterValue>& parameters)> cb) {
AudioParameter halKeys;
for (auto& pair : context) {
halKeys.add(String8(pair.key.c_str()), String8(pair.value.c_str()));
}
for (size_t i = 0; i < keys.size(); ++i) {
halKeys.addKey(String8(keys[i].c_str()));
}
std::unique_ptr<AudioParameter> halValues = getParams(halKeys);
Result retval =
(keys.size() == 0 || halValues->size() != 0) ? Result::OK : Result::NOT_SUPPORTED;
hidl_vec<ParameterValue> result;
result.resize(halValues->size());
String8 halKey, halValue;
for (size_t i = 0; i < halValues->size(); ++i) {
status_t status = halValues->getAt(i, halKey, halValue);
if (status != OK) {
result.resize(0);
retval = getHalStatusToResult(status);
break;
}
result[i].key = halKey.string();
result[i].value = halValue.string();
}
cb(retval, result);
}
std::unique_ptr<AudioParameter> ParametersUtil::getParams(const AudioParameter& keys) {
String8 paramsAndValues;
char* halValues = halGetParameters(keys.keysToString().string());
if (halValues != NULL) {
paramsAndValues.setTo(halValues);
free(halValues);
} else {
paramsAndValues.clear();
}
return std::unique_ptr<AudioParameter>(new AudioParameter(paramsAndValues));
}
Result ParametersUtil::setParam(const char* name, const char* value) {
AudioParameter param;
param.add(String8(name), String8(value));
return setParams(param);
}
Result ParametersUtil::setParam(const char* name, bool value) {
AudioParameter param;
param.add(String8(name), String8(value ? AudioParameter::valueOn : AudioParameter::valueOff));
return setParams(param);
}
Result ParametersUtil::setParam(const char* name, int value) {
AudioParameter param;
param.addInt(String8(name), value);
return setParams(param);
}
Result ParametersUtil::setParam(const char* name, float value) {
AudioParameter param;
param.addFloat(String8(name), value);
return setParams(param);
}
int getMixerValueByName(const char *name) {
const auto mixer = mixer_open(0);
const auto ctl = mixer_get_ctl_by_name(mixer, name);
int value = 0;
if (mixer == nullptr) {
ALOGE("Failed to find mixer ctl for %s", name);
return 0;
}
if (ctl == nullptr) {
ALOGE("Failed to find mixer ctl for %s", name);
return 0;
}
value = mixer_ctl_get_value(ctl, 0);
mixer_close(mixer);
return value;
}
const char *getMixerValueString(const char *name) {
const auto mixer = mixer_open(0);
const auto ctl = mixer_get_ctl_by_name(mixer, name);
int control_value = mixer_ctl_get_value(ctl, 0);
const char *value;
if (mixer == nullptr) {
ALOGE("Failed to find mixer ctl for %s", name);
return "-1";
}
if (ctl == nullptr) {
ALOGE("Failed to find mixer ctl for %s", name);
return "-1";
}
value = mixer_ctl_get_enum_string(ctl, control_value);
mixer_close(mixer);
return value;
}
void setMixerValueByName(mixer *mixer, const char *name, int value) {
const auto ctl = mixer_get_ctl_by_name(mixer, name);
if (ctl == nullptr) {
ALOGE("Failed to find mixer ctl for %s", name);
return;
}
if (mixer_ctl_set_value(ctl, 0, value) < 0) {
ALOGE("Failed to find mixer ctl for %s", name);
return;
}
}
void setMixerValueByNameString(mixer *mixer, const char *name, const char *value) {
const auto ctl = mixer_get_ctl_by_name(mixer, name);
if (ctl == nullptr) {
ALOGE("Failed to find mixer ctl for %s", name);
return;
}
if (mixer_ctl_set_enum_by_string(ctl, value)) {
ALOGE("Failed to find mixer ctl for %s", name);
return;
}
}
void setEarpieceVoipMixers(bool enabled) {
const auto mixer = mixer_open(0);
if (mixer == nullptr) {
ALOGE("Failed to open mixer");
return;
}
if (enabled) {
setMixerValueByNameString(mixer, "TX SMIC MUX0", "ADC0");
setMixerValueByNameString(mixer, "TX SMIC MUX1", "ADC2");
setMixerValueByName(mixer, "MultiMedia2 Mixer QUIN_MI2S_TX", 0);
setMixerValueByNameString(mixer, "TAS256X ASI1 SEL RIGHT", "I2C offset");
setMixerValueByName(mixer, "TAS256X ASI Right Switch", 0);
setMixerValueByNameString(mixer, "TAS256X ASI1 SEL LEFT", "LeftRightDiv2");
setMixerValueByName(mixer, "TAS256X RECEIVER ENABLE LEFT", 1);
setMixerValueByName(mixer, "TAS256X ASI Left Switch", 1);
setMixerValueByName(mixer, "TAS256X AMP OUTPUT LVL LEFT", 8);
setMixerValueByName(mixer, "TAS256X PLAYBACK VOLUME LEFT", 55);
setMixerValueByName(mixer, "TAS256X PLAYBACK VOLUME RIGHT", 55);
setMixerValueByName(mixer, "SmartPA Mute", 0);
setMixerValueByNameString(mixer, "EC Reference Channels", "One");
setMixerValueByNameString(mixer, "AUDIO_REF_EC_UL10 MUX", "QUIN_MI2S_RX");
setMixerValueByName(mixer, "Voip_Tx Mixer SLIM_7_TX_Voip", 0);
setMixerValueByName(mixer, "SLIM_7_RX_Voice Mixer Voip", 0);
setMixerValueByName(mixer, "QUIN_MI2S_RX_Voice Mixer Voip", 1);
setMixerValueByName(mixer, "Voip_Tx Mixer TX_CDC_DMA_TX_3_Voip", 1);
setMixerValueByName(mixer, "QUIN_MI2S_RX_Voice Mixer Voip", 0);
setMixerValueByName(mixer, "Voip_Tx Mixer TX_CDC_DMA_TX_3_Voip", 0);
}
mixer_close(mixer);
}
void setSpeakerVoipMixers(bool enabled) {
const auto mixer = mixer_open(0);
if (mixer == nullptr) {
ALOGE("Failed to open mixer");
return;
}
if (enabled) {
setMixerValueByNameString(mixer, "TX SMIC MUX0", "ADC2");
setMixerValueByNameString(mixer, "TX SMIC MUX1", "ADC0");
setMixerValueByName(mixer, "MultiMedia2 Mixer QUIN_MI2S_TX", 1);
setMixerValueByNameString(mixer, "TAS256X ASI1 SEL RIGHT", "Right");
setMixerValueByName(mixer, "TAS256X ASI Right Switch", 1);
setMixerValueByNameString(mixer, "TAS256X ASI1 SEL LEFT", "Left");
setMixerValueByName(mixer, "TAS256X RECEIVER ENABLE LEFT", 0);
setMixerValueByName(mixer, "TAS256X ASI Left Switch", 1);
setMixerValueByName(mixer, "TAS256X AMP OUTPUT LVL LEFT", 20);
setMixerValueByName(mixer, "TAS256X PLAYBACK VOLUME LEFT", 55);
setMixerValueByName(mixer, "TAS256X PLAYBACK VOLUME RIGHT", 55);
setMixerValueByName(mixer, "SmartPA Mute", 0);
setMixerValueByNameString(mixer, "EC Reference Channels", "Two");
setMixerValueByNameString(mixer, "AUDIO_REF_EC_UL10 MUX", "QUIN_MI2S_RX");
setMixerValueByName(mixer, "Voip_Tx Mixer SLIM_7_TX_Voip", 0);
setMixerValueByName(mixer, "SLIM_7_RX_Voice Mixer Voip", 0);
setMixerValueByName(mixer, "QUIN_MI2S_RX_Voice Mixer Voip", 1);
setMixerValueByName(mixer, "Voip_Tx Mixer TX_CDC_DMA_TX_3_Voip", 1);
setMixerValueByName(mixer, "QUIN_MI2S_RX_Voice Mixer Voip", 0);
setMixerValueByName(mixer, "Voip_Tx Mixer TX_CDC_DMA_TX_3_Voip", 0);
}
mixer_close(mixer);
}
void setBTVoipMixers(bool enabled) {
const auto mixer = mixer_open(0);
if (mixer == nullptr) {
ALOGE("Failed to open mixer");
return;
}
if (enabled) {
setMixerValueByName(mixer, "TX_AIF1_CAP Mixer DEC0", 0);
setMixerValueByName(mixer, "TX_AIF1_CAP Mixer DEC1", 0);
setMixerValueByNameString(mixer, "TX SMIC MUX0", "ZERO");
setMixerValueByNameString(mixer, "TX SMIC MUX1", "ZERO");
setMixerValueByNameString(mixer, "TX DEC0 MUX", "MSM_DMIC");
setMixerValueByNameString(mixer, "TX DEC1 MUX", "MSM_DMIC");
setMixerValueByName(mixer, "TX_DEC0 Volume", 102);
setMixerValueByName(mixer, "TX_DEC1 Volume", 102);
setMixerValueByName(mixer, "Voip_Tx Mixer SLIM_7_TX_Voip", 1);
setMixerValueByName(mixer, "Voip_Tx Mixer TX_CDC_DMA_TX_3_Voip", 0);
setMixerValueByName(mixer, "SLIM_7_RX_Voice Mixer Voip", 1);
setMixerValueByName(mixer, "QUIN_MI2S_RX_Voice Mixer Voip", 0);
setMixerValueByName(mixer, "TAS256X IVSENSE ENABLE", 0);
setMixerValueByName(mixer, "TAS256X PLAYBACK VOLUME LEFT", 55);
setMixerValueByName(mixer, "TAS256X RECEIVER ENABLE LEFT", 0);
setMixerValueByName(mixer, "TAS256X AMP OUTPUT LVL LEFT", 20);
setMixerValueByName(mixer, "SmartPA Mute", 1);
setMixerValueByName(mixer, "ADC1 Volume", 12);
setMixerValueByName(mixer, "ADC3 Volume", 12);
setMixerValueByNameString(mixer, "TX_CDC_DMA_TX_3 Channels", "One");
setMixerValueByName(mixer, "TAS256X ASI Left Switch", 0);
setMixerValueByNameString(mixer, "TAS256X ASI1 SEL LEFT", "I2C Offset");
setMixerValueByName(mixer, "ADC3_MIXER Switch", 0);
}
mixer_close(mixer);
}
void fixupMixers() {
char simslot[92];
char voipdevice[92];
const char *ampstatus;
int voipstatus, btvoipstatus;
property_get("vendor.calls.slotid", simslot, "-1");
property_get("vendor.audio.voip.device", voipdevice, "none");
voipstatus = getMixerValueByName("QUIN_MI2S_RX_Voice Mixer Voip");
ampstatus = getMixerValueString("TAS256X RECEIVER ENABLE LEFT");
btvoipstatus = getMixerValueByName("SLIM_7_RX_Voice Mixer Voip");
ALOGD("ampstatus is %s", ampstatus);
ALOGD("voipstatus is %d", voipstatus);
ALOGD("bluetooth VoIP status is %d", btvoipstatus);
// VoIP call
if (voipstatus == 1 || btvoipstatus == 1) {
ALOGD("In VoIP call");
if (strcmp(voipdevice, "bluetooth") == 0 && btvoipstatus == 0) {
ALOGD("Setting bluetooth mixers");
setBTVoipMixers(true);
}
if (strcmp(voipdevice, "earpiece") == 0) {
if (btvoipstatus == 1 || strcmp(ampstatus, "DISABLE") == 0) {
ALOGD("Setting earpiece mixers");
setEarpieceVoipMixers(true);
}
}
if (strcmp(voipdevice, "speaker") == 0) {
if (btvoipstatus == 1 || strcmp(ampstatus, "ENABLE") == 0) {
ALOGD("Setting speaker mixers");
setSpeakerVoipMixers(true);
}
}
}
}
Result ParametersUtil::setParametersImpl(const hidl_vec<ParameterValue>& context,
const hidl_vec<ParameterValue>& parameters) {
AudioParameter params;
for (auto& pair : context) {
params.add(String8(pair.key.c_str()), String8(pair.value.c_str()));
}
for (size_t i = 0; i < parameters.size(); ++i) {
if (parameters[i].key == "bt_wbs") {
params.add(String8("g_sco_samplerate"),
String8(parameters[i].value == AudioParameter::valueOn ? "16000" : "8000"));
}
if (parameters[i].key == "voip_call") {
if (parameters[i].value == "1") {
fixupMixers();
}
}
params.add(String8(parameters[i].key.c_str()), String8(parameters[i].value.c_str()));
}
return setParams(params);
}
Result ParametersUtil::setParam(const char* name, const DeviceAddress& address) {
audio_devices_t halDeviceType;
char halDeviceAddress[AUDIO_DEVICE_MAX_ADDRESS_LEN];
if (CoreUtils::deviceAddressToHal(address, &halDeviceType, halDeviceAddress) != NO_ERROR) {
return Result::INVALID_ARGUMENTS;
}
AudioParameter params{String8(halDeviceAddress)};
params.addInt(String8(name), halDeviceType);
return setParams(params);
}
Result ParametersUtil::setParams(const AudioParameter& param) {
int halStatus = halSetParameters(param.toString().string());
return util::analyzeStatus(halStatus);
}
} // namespace implementation
} // namespace CORE_TYPES_CPP_VERSION
} // namespace audio
} // namespace hardware
} // namespace android