int msm_audio_effects_enable_extn(struct audio_client *ac,
struct msm_nt_eff_all_config *effects,
bool flag)
{
uint32_t updt_params[MAX_ENABLE_CMD_SIZE] = {0};
uint32_t params_length;
int rc = 0;
pr_debug("%s\n", __func__);
if (!ac) {
pr_err("%s: cannot set audio effects\n", __func__);
return -EINVAL;
}
params_length = 0;
updt_params[0] = AUDPROC_MODULE_ID_VIRTUALIZER;
updt_params[1] = AUDPROC_PARAM_ID_ENABLE;
updt_params[2] = VIRTUALIZER_ENABLE_PARAM_SZ;
updt_params[3] = flag;
params_length += COMMAND_PAYLOAD_SZ + VIRTUALIZER_ENABLE_PARAM_SZ;
if (effects->virtualizer.enable_flag)
q6asm_send_audio_effects_params(ac, (char *)&updt_params[0],
params_length);
memset(updt_params, 0, MAX_ENABLE_CMD_SIZE);
params_length = 0;
updt_params[0] = AUDPROC_MODULE_ID_BASS_BOOST;
updt_params[1] = AUDPROC_PARAM_ID_ENABLE;
updt_params[2] = BASS_BOOST_ENABLE_PARAM_SZ;
updt_params[3] = flag;
params_length += COMMAND_PAYLOAD_SZ + BASS_BOOST_ENABLE_PARAM_SZ;
if (effects->bass_boost.enable_flag)
q6asm_send_audio_effects_params(ac, (char *)&updt_params[0],
params_length);
memset(updt_params, 0, MAX_ENABLE_CMD_SIZE);
params_length = 0;
updt_params[0] = AUDPROC_MODULE_ID_POPLESS_EQUALIZER;
updt_params[1] = AUDPROC_PARAM_ID_ENABLE;
updt_params[2] = EQ_ENABLE_PARAM_SZ;
updt_params[3] = flag;
params_length += COMMAND_PAYLOAD_SZ + EQ_ENABLE_PARAM_SZ;
if (effects->equalizer.enable_flag)
q6asm_send_audio_effects_params(ac, (char *)&updt_params[0],
params_length);
return rc;
}
int msm_audio_effects_popless_eq_handler(struct audio_client *ac,
struct eq_params *eq,
long *values)
{
int devices = *values++;
int num_commands = *values++;
char *params;
int *updt_params, i, prev_enable_flag;
uint32_t params_length = (MAX_INBAND_PARAM_SZ);
int rc = 0;
pr_debug("%s\n", __func__);
if (!ac) {
pr_err("%s: cannot set audio effects\n", __func__);
return -EINVAL;
}
params = kzalloc(params_length, GFP_KERNEL);
if (!params) {
pr_err("%s, params memory alloc failed\n", __func__);
return -ENOMEM;
}
pr_debug("%s: device: %d\n", __func__, devices);
updt_params = (int *)params;
params_length = 0;
for (i = 0; i < num_commands; i++) {
uint32_t command_id = *values++;
uint32_t command_config_state = *values++;
uint32_t index_offset = *values++;
uint32_t length = *values++;
int idx, j;
switch (command_id) {
case EQ_ENABLE:
if (length != 1 || index_offset != 0) {
pr_err("EQ_ENABLE:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
prev_enable_flag = eq->enable_flag;
eq->enable_flag = *values++;
pr_debug("%s: EQ_ENABLE prev:%d new:%d\n", __func__,
prev_enable_flag, eq->enable_flag);
if (prev_enable_flag != eq->enable_flag) {
*updt_params++ =
AUDPROC_MODULE_ID_POPLESS_EQUALIZER;
*updt_params++ = AUDPROC_PARAM_ID_EQ_ENABLE;
*updt_params++ = EQ_ENABLE_PARAM_SZ;
*updt_params++ = eq->enable_flag;
params_length += COMMAND_PAYLOAD_SZ +
EQ_ENABLE_PARAM_SZ;
}
break;
case EQ_CONFIG:
if (length < EQ_CONFIG_PARAM_LEN || index_offset != 0) {
pr_err("EQ_CONFIG:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
pr_debug("%s: EQ_CONFIG bands:%d, pgain:%d, pset:%d\n",
__func__, eq->config.num_bands,
eq->config.eq_pregain, eq->config.preset_id);
for (idx = 0; idx < MAX_EQ_BANDS; idx++)
eq->per_band_cfg[idx].band_idx = -1;
eq->config.eq_pregain = *values++;
eq->config.preset_id = *values++;
eq->config.num_bands = *values++;
if (eq->config.num_bands > MAX_EQ_BANDS) {
pr_err("EQ_CONFIG:invalid num of bands\n");
rc = -EINVAL;
goto invalid_config;
}
if (eq->config.num_bands &&
(((length - EQ_CONFIG_PARAM_LEN)/
EQ_CONFIG_PER_BAND_PARAM_LEN)
!= eq->config.num_bands)) {
pr_err("EQ_CONFIG:invalid length per band\n");
rc = -EINVAL;
goto invalid_config;
}
for (j = 0; j < eq->config.num_bands; j++) {
idx = *values++;
if (idx >= MAX_EQ_BANDS) {
pr_err("EQ_CONFIG:invalid band index\n");
rc = -EINVAL;
goto invalid_config;
}
eq->per_band_cfg[idx].band_idx = idx;
eq->per_band_cfg[idx].filter_type = *values++;
eq->per_band_cfg[idx].freq_millihertz =
*values++;
eq->per_band_cfg[idx].gain_millibels =
*values++;
eq->per_band_cfg[idx].quality_factor =
*values++;
}
if (command_config_state == CONFIG_SET) {
int config_param_length = EQ_CONFIG_PARAM_SZ +
(EQ_CONFIG_PER_BAND_PARAM_SZ*
eq->config.num_bands);
*updt_params++ =
AUDPROC_MODULE_ID_POPLESS_EQUALIZER;
*updt_params++ = AUDPROC_PARAM_ID_EQ_CONFIG;
*updt_params++ = config_param_length;
*updt_params++ = eq->config.eq_pregain;
*updt_params++ = eq->config.preset_id;
*updt_params++ = eq->config.num_bands;
for (idx = 0; idx < MAX_EQ_BANDS; idx++) {
if (eq->per_band_cfg[idx].band_idx < 0)
continue;
*updt_params++ =
eq->per_band_cfg[idx].filter_type;
*updt_params++ =
eq->per_band_cfg[idx].freq_millihertz;
*updt_params++ =
eq->per_band_cfg[idx].gain_millibels;
*updt_params++ =
eq->per_band_cfg[idx].quality_factor;
*updt_params++ =
eq->per_band_cfg[idx].band_idx;
}
params_length += COMMAND_PAYLOAD_SZ +
config_param_length;
}
break;
case EQ_BAND_INDEX:
if (length != 1 || index_offset != 0) {
pr_err("EQ_BAND_INDEX:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
idx = *values++;
if (idx > MAX_EQ_BANDS) {
pr_err("EQ_BAND_INDEX:invalid band index\n");
rc = -EINVAL;
goto invalid_config;
}
eq->band_index = idx;
pr_debug("%s: EQ_BAND_INDEX val:%d\n",
__func__, eq->band_index);
if (command_config_state == CONFIG_SET) {
*updt_params++ =
AUDPROC_MODULE_ID_POPLESS_EQUALIZER;
*updt_params++ =
AUDPROC_PARAM_ID_EQ_BAND_INDEX;
*updt_params++ = EQ_BAND_INDEX_PARAM_SZ;
*updt_params++ = eq->band_index;
params_length += COMMAND_PAYLOAD_SZ +
EQ_BAND_INDEX_PARAM_SZ;
}
break;
case EQ_SINGLE_BAND_FREQ:
if (length != 1 || index_offset != 0) {
pr_err("EQ_SINGLE_BAND_FREQ:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
if (eq->band_index > MAX_EQ_BANDS) {
pr_err("EQ_SINGLE_BAND_FREQ:invalid index\n");
break;
}
eq->freq_millihertz = *values++;
pr_debug("%s: EQ_SINGLE_BAND_FREQ idx:%d, val:%d\n",
__func__, eq->band_index, eq->freq_millihertz);
if (command_config_state == CONFIG_SET) {
*updt_params++ =
AUDPROC_MODULE_ID_POPLESS_EQUALIZER;
*updt_params++ =
AUDPROC_PARAM_ID_EQ_SINGLE_BAND_FREQ;
*updt_params++ = EQ_SINGLE_BAND_FREQ_PARAM_SZ;
*updt_params++ = eq->freq_millihertz;
params_length += COMMAND_PAYLOAD_SZ +
EQ_SINGLE_BAND_FREQ_PARAM_SZ;
}
break;
default:
pr_err("%s: Invalid command to set config\n", __func__);
break;
}
}
if (params_length)
q6asm_send_audio_effects_params(ac, params,
params_length);
invalid_config:
kfree(params);
return rc;
}
int msm_audio_effects_bass_boost_handler(struct audio_client *ac,
struct bass_boost_params *bass_boost,
long *values)
{
int devices = *values++;
int num_commands = *values++;
char *params;
int *updt_params, i, prev_enable_flag;
uint32_t params_length = (MAX_INBAND_PARAM_SZ);
int rc = 0;
pr_debug("%s\n", __func__);
if (!ac) {
pr_err("%s: cannot set audio effects\n", __func__);
return -EINVAL;
}
params = kzalloc(params_length, GFP_KERNEL);
if (!params) {
pr_err("%s, params memory alloc failed\n", __func__);
return -ENOMEM;
}
pr_debug("%s: device: %d\n", __func__, devices);
updt_params = (int *)params;
params_length = 0;
for (i = 0; i < num_commands; i++) {
uint32_t command_id = *values++;
uint32_t command_config_state = *values++;
uint32_t index_offset = *values++;
uint32_t length = *values++;
switch (command_id) {
case BASS_BOOST_ENABLE:
if (length != 1 || index_offset != 0) {
pr_err("BASS_BOOST_ENABLE:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
prev_enable_flag = bass_boost->enable_flag;
bass_boost->enable_flag = *values++;
pr_debug("%s: BASS_BOOST_ENABLE prev:%d new:%d\n",
__func__, prev_enable_flag,
bass_boost->enable_flag);
if (prev_enable_flag != bass_boost->enable_flag) {
*updt_params++ = AUDPROC_MODULE_ID_BASS_BOOST;
*updt_params++ =
AUDPROC_PARAM_ID_BASS_BOOST_ENABLE;
*updt_params++ = BASS_BOOST_ENABLE_PARAM_SZ;
*updt_params++ = bass_boost->enable_flag;
params_length += COMMAND_PAYLOAD_SZ +
BASS_BOOST_ENABLE_PARAM_SZ;
}
break;
case BASS_BOOST_MODE:
if (length != 1 || index_offset != 0) {
pr_err("BASS_BOOST_MODE:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
bass_boost->mode = *values++;
pr_debug("%s: BASS_BOOST_MODE val:%d\n",
__func__, bass_boost->mode);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_BASS_BOOST;
*updt_params++ =
AUDPROC_PARAM_ID_BASS_BOOST_MODE;
*updt_params++ = BASS_BOOST_MODE_PARAM_SZ;
*updt_params++ = bass_boost->mode;
params_length += COMMAND_PAYLOAD_SZ +
BASS_BOOST_MODE_PARAM_SZ;
}
break;
case BASS_BOOST_STRENGTH:
if (length != 1 || index_offset != 0) {
pr_err("BASS_BOOST_STRENGTH:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
bass_boost->strength = *values++;
pr_debug("%s: BASS_BOOST_STRENGTHi val:%d\n",
__func__, bass_boost->strength);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_BASS_BOOST;
*updt_params++ =
AUDPROC_PARAM_ID_BASS_BOOST_STRENGTH;
*updt_params++ = BASS_BOOST_STRENGTH_PARAM_SZ;
*updt_params++ = bass_boost->strength;
params_length += COMMAND_PAYLOAD_SZ +
BASS_BOOST_STRENGTH_PARAM_SZ;
}
break;
default:
pr_err("%s: Invalid command to set config\n", __func__);
break;
}
}
if (params_length)
q6asm_send_audio_effects_params(ac, params,
params_length);
invalid_config:
kfree(params);
return rc;
}
int msm_audio_effects_virtualizer_handler(struct audio_client *ac,
struct virtualizer_params *virtualizer,
long *values)
{
int devices = *values++;
int num_commands = *values++;
char *params;
int *updt_params, i, prev_enable_flag;
uint32_t params_length = (MAX_INBAND_PARAM_SZ);
int rc = 0;
pr_debug("%s\n", __func__);
if (!ac) {
pr_err("%s: cannot set audio effects\n", __func__);
return -EINVAL;
}
params = kzalloc(params_length, GFP_KERNEL);
if (!params) {
pr_err("%s, params memory alloc failed\n", __func__);
return -ENOMEM;
}
pr_debug("%s: device: %d\n", __func__, devices);
updt_params = (int *)params;
params_length = 0;
for (i = 0; i < num_commands; i++) {
uint32_t command_id = *values++;
uint32_t command_config_state = *values++;
uint32_t index_offset = *values++;
uint32_t length = *values++;
switch (command_id) {
case VIRTUALIZER_ENABLE:
if (length != 1 || index_offset != 0) {
pr_err("VIRT ENABLE:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
prev_enable_flag = virtualizer->enable_flag;
virtualizer->enable_flag = *values++;
pr_debug("%s:VIRT ENABLE prev:%d, new:%d\n", __func__,
prev_enable_flag, virtualizer->enable_flag);
if (prev_enable_flag != virtualizer->enable_flag) {
*updt_params++ = AUDPROC_MODULE_ID_VIRTUALIZER;
*updt_params++ =
AUDPROC_PARAM_ID_VIRTUALIZER_ENABLE;
*updt_params++ = VIRTUALIZER_ENABLE_PARAM_SZ;
*updt_params++ = virtualizer->enable_flag;
params_length += COMMAND_PAYLOAD_SZ +
VIRTUALIZER_ENABLE_PARAM_SZ;
}
break;
case VIRTUALIZER_STRENGTH:
if (length != 1 || index_offset != 0) {
pr_err("VIRT STRENGTH:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
virtualizer->strength = *values++;
pr_debug("%s: VIRT STRENGTH val: %d\n",
__func__, virtualizer->strength);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_VIRTUALIZER;
*updt_params++ =
AUDPROC_PARAM_ID_VIRTUALIZER_STRENGTH;
*updt_params++ = VIRTUALIZER_STRENGTH_PARAM_SZ;
*updt_params++ = virtualizer->strength;
params_length += COMMAND_PAYLOAD_SZ +
VIRTUALIZER_STRENGTH_PARAM_SZ;
}
break;
case VIRTUALIZER_OUT_TYPE:
if (length != 1 || index_offset != 0) {
pr_err("VIRT OUT_TYPE:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
virtualizer->out_type = *values++;
pr_debug("%s: VIRT OUT_TYPE val:%d\n",
__func__, virtualizer->out_type);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_VIRTUALIZER;
*updt_params++ =
AUDPROC_PARAM_ID_VIRTUALIZER_OUT_TYPE;
*updt_params++ = VIRTUALIZER_OUT_TYPE_PARAM_SZ;
*updt_params++ = virtualizer->out_type;
params_length += COMMAND_PAYLOAD_SZ +
VIRTUALIZER_OUT_TYPE_PARAM_SZ;
}
break;
case VIRTUALIZER_GAIN_ADJUST:
if (length != 1 || index_offset != 0) {
pr_err("VIRT GAIN_ADJUST: invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
virtualizer->gain_adjust = *values++;
pr_debug("%s: VIRT GAIN_ADJUST val:%d\n",
__func__, virtualizer->gain_adjust);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_VIRTUALIZER;
*updt_params++ =
AUDPROC_PARAM_ID_VIRTUALIZER_GAIN_ADJUST;
*updt_params++ =
VIRTUALIZER_GAIN_ADJUST_PARAM_SZ;
*updt_params++ = virtualizer->gain_adjust;
params_length += COMMAND_PAYLOAD_SZ +
VIRTUALIZER_GAIN_ADJUST_PARAM_SZ;
}
break;
default:
pr_err("%s: Invalid command to set config\n", __func__);
break;
}
}
if (params_length)
q6asm_send_audio_effects_params(ac, params,
params_length);
invalid_config:
kfree(params);
return rc;
}
int msm_audio_effects_reverb_handler(struct audio_client *ac,
struct reverb_params *reverb,
long *values)
{
int devices = *values++;
int num_commands = *values++;
char *params;
int *updt_params, i, prev_enable_flag;
uint32_t params_length = (MAX_INBAND_PARAM_SZ);
int rc = 0;
pr_debug("%s\n", __func__);
if (!ac) {
pr_err("%s: cannot set audio effects\n", __func__);
return -EINVAL;
}
params = kzalloc(params_length, GFP_KERNEL);
if (!params) {
pr_err("%s, params memory alloc failed\n", __func__);
return -ENOMEM;
}
pr_debug("%s: device: %d\n", __func__, devices);
updt_params = (int *)params;
params_length = 0;
for (i = 0; i < num_commands; i++) {
uint32_t command_id = *values++;
uint32_t command_config_state = *values++;
uint32_t index_offset = *values++;
uint32_t length = *values++;
switch (command_id) {
case REVERB_ENABLE:
if (length != 1 || index_offset != 0) {
pr_err("REVERB_ENABLE:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
prev_enable_flag = reverb->enable_flag;
reverb->enable_flag = *values++;
pr_debug("%s:REVERB_ENABLE prev:%d,new:%d\n", __func__,
prev_enable_flag, reverb->enable_flag);
if (prev_enable_flag != reverb->enable_flag) {
*updt_params++ = AUDPROC_MODULE_ID_REVERB;
*updt_params++ = AUDPROC_PARAM_ID_REVERB_ENABLE;
*updt_params++ = REVERB_ENABLE_PARAM_SZ;
*updt_params++ = reverb->enable_flag;
params_length += COMMAND_PAYLOAD_SZ +
REVERB_ENABLE_PARAM_SZ;
}
break;
case REVERB_MODE:
if (length != 1 || index_offset != 0) {
pr_err("REVERB_MODE:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
reverb->mode = *values++;
pr_debug("%s: REVERB_MODE val:%d\n",
__func__, reverb->mode);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_REVERB;
*updt_params++ = AUDPROC_PARAM_ID_REVERB_MODE;
*updt_params++ = REVERB_MODE_PARAM_SZ;
*updt_params++ = reverb->mode;
params_length += COMMAND_PAYLOAD_SZ +
REVERB_MODE_PARAM_SZ;
}
break;
case REVERB_PRESET:
if (length != 1 || index_offset != 0) {
pr_err("REVERB_PRESET:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
reverb->preset = *values++;
pr_debug("%s: REVERB_PRESET val:%d\n",
__func__, reverb->preset);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_REVERB;
*updt_params++ = AUDPROC_PARAM_ID_REVERB_PRESET;
*updt_params++ = REVERB_PRESET_PARAM_SZ;
*updt_params++ = reverb->preset;
params_length += COMMAND_PAYLOAD_SZ +
REVERB_PRESET_PARAM_SZ;
}
break;
case REVERB_WET_MIX:
if (length != 1 || index_offset != 0) {
pr_err("REVERB_WET_MIX:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
reverb->wet_mix = *values++;
pr_debug("%s: REVERB_WET_MIX val:%d\n",
__func__, reverb->wet_mix);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_REVERB;
*updt_params++ =
AUDPROC_PARAM_ID_REVERB_WET_MIX;
*updt_params++ = REVERB_WET_MIX_PARAM_SZ;
*updt_params++ = reverb->wet_mix;
params_length += COMMAND_PAYLOAD_SZ +
REVERB_WET_MIX_PARAM_SZ;
}
break;
case REVERB_GAIN_ADJUST:
if (length != 1 || index_offset != 0) {
pr_err("REVERB_GAIN_ADJUST:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
reverb->gain_adjust = *values++;
pr_debug("%s: REVERB_GAIN_ADJUST val:%d\n",
__func__, reverb->gain_adjust);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_REVERB;
*updt_params++ =
AUDPROC_PARAM_ID_REVERB_GAIN_ADJUST;
*updt_params++ = REVERB_GAIN_ADJUST_PARAM_SZ;
*updt_params++ = reverb->gain_adjust;
params_length += COMMAND_PAYLOAD_SZ +
REVERB_GAIN_ADJUST_PARAM_SZ;
}
break;
case REVERB_ROOM_LEVEL:
if (length != 1 || index_offset != 0) {
pr_err("REVERB_ROOM_LEVEL:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
reverb->room_level = *values++;
pr_debug("%s: REVERB_ROOM_LEVEL val:%d\n",
__func__, reverb->room_level);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_REVERB;
*updt_params++ =
AUDPROC_PARAM_ID_REVERB_ROOM_LEVEL;
*updt_params++ = REVERB_ROOM_LEVEL_PARAM_SZ;
*updt_params++ = reverb->room_level;
params_length += COMMAND_PAYLOAD_SZ +
REVERB_ROOM_LEVEL_PARAM_SZ;
}
break;
case REVERB_ROOM_HF_LEVEL:
if (length != 1 || index_offset != 0) {
pr_err("REVERB_ROOM_HF_LEVEL:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
reverb->room_hf_level = *values++;
pr_debug("%s: REVERB_ROOM_HF_LEVEL val%d\n",
__func__, reverb->room_hf_level);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_REVERB;
*updt_params++ =
AUDPROC_PARAM_ID_REVERB_ROOM_HF_LEVEL;
*updt_params++ = REVERB_ROOM_HF_LEVEL_PARAM_SZ;
*updt_params++ = reverb->room_hf_level;
params_length += COMMAND_PAYLOAD_SZ +
REVERB_ROOM_HF_LEVEL_PARAM_SZ;
}
break;
case REVERB_DECAY_TIME:
if (length != 1 || index_offset != 0) {
pr_err("REVERB_DECAY_TIME:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
reverb->decay_time = *values++;
pr_debug("%s: REVERB_DECAY_TIME val:%d\n",
__func__, reverb->decay_time);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_REVERB;
*updt_params++ =
AUDPROC_PARAM_ID_REVERB_DECAY_TIME;
*updt_params++ = REVERB_DECAY_TIME_PARAM_SZ;
*updt_params++ = reverb->decay_time;
params_length += COMMAND_PAYLOAD_SZ +
REVERB_DECAY_TIME_PARAM_SZ;
}
break;
case REVERB_DECAY_HF_RATIO:
if (length != 1 || index_offset != 0) {
pr_err("REVERB_DECAY_HF_RATIOinvalid params\n");
rc = -EINVAL;
goto invalid_config;
}
reverb->decay_hf_ratio = *values++;
pr_debug("%s: REVERB_DECAY_HF_RATIO val%d\n",
__func__, reverb->decay_hf_ratio);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_REVERB;
*updt_params++ =
AUDPROC_PARAM_ID_REVERB_DECAY_HF_RATIO;
*updt_params++ = REVERB_DECAY_HF_RATIO_PARAM_SZ;
*updt_params++ = reverb->decay_hf_ratio;
params_length += COMMAND_PAYLOAD_SZ +
REVERB_DECAY_HF_RATIO_PARAM_SZ;
}
break;
case REVERB_REFLECTIONS_LEVEL:
if (length != 1 || index_offset != 0) {
pr_err("REVERB_REFLECTION_LVLinvalid params\n");
rc = -EINVAL;
goto invalid_config;
}
reverb->reflections_level = *values++;
pr_debug("%s: REVERB_REFLECTIONS_LEVEL val:%d\n",
__func__, reverb->reflections_level);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_REVERB;
*updt_params++ =
AUDPROC_PARAM_ID_REVERB_REFLECTIONS_LEVEL;
*updt_params++ =
REVERB_REFLECTIONS_LEVEL_PARAM_SZ;
*updt_params++ = reverb->reflections_level;
params_length += COMMAND_PAYLOAD_SZ +
REVERB_REFLECTIONS_LEVEL_PARAM_SZ;
}
break;
case REVERB_REFLECTIONS_DELAY:
if (length != 1 || index_offset != 0) {
pr_err("REVERB_REFLECTION_DLYinvalid params\n");
rc = -EINVAL;
goto invalid_config;
}
reverb->reflections_delay = *values++;
pr_debug("%s: REVERB_REFLECTIONS_DELAY val:%d\n",
__func__, reverb->reflections_delay);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_REVERB;
*updt_params++ =
AUDPROC_PARAM_ID_REVERB_REFLECTIONS_DELAY;
*updt_params++ =
REVERB_REFLECTIONS_DELAY_PARAM_SZ;
*updt_params++ = reverb->reflections_delay;
params_length += COMMAND_PAYLOAD_SZ +
REVERB_REFLECTIONS_DELAY_PARAM_SZ;
}
break;
case REVERB_LEVEL:
if (length != 1 || index_offset != 0) {
pr_err("REVERB_LEVEL:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
reverb->level = *values++;
pr_debug("%s: REVERB_LEVEL val:%d\n",
__func__, reverb->level);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_REVERB;
*updt_params++ = AUDPROC_PARAM_ID_REVERB_LEVEL;
*updt_params++ = REVERB_LEVEL_PARAM_SZ;
*updt_params++ = reverb->level;
params_length += COMMAND_PAYLOAD_SZ +
REVERB_LEVEL_PARAM_SZ;
}
break;
case REVERB_DELAY:
if (length != 1 || index_offset != 0) {
pr_err("REVERB_DELAY:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
reverb->delay = *values++;
pr_debug("%s:REVERB_DELAY val:%d\n",
__func__, reverb->delay);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_REVERB;
*updt_params++ = AUDPROC_PARAM_ID_REVERB_DELAY;
*updt_params++ = REVERB_DELAY_PARAM_SZ;
*updt_params++ = reverb->delay;
params_length += COMMAND_PAYLOAD_SZ +
REVERB_DELAY_PARAM_SZ;
}
break;
case REVERB_DIFFUSION:
if (length != 1 || index_offset != 0) {
pr_err("REVERB_DIFFUSION:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
reverb->diffusion = *values++;
pr_debug("%s: REVERB_DIFFUSION val:%d\n",
__func__, reverb->diffusion);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_REVERB;
*updt_params++ =
AUDPROC_PARAM_ID_REVERB_DIFFUSION;
*updt_params++ = REVERB_DIFFUSION_PARAM_SZ;
*updt_params++ = reverb->diffusion;
params_length += COMMAND_PAYLOAD_SZ +
REVERB_DIFFUSION_PARAM_SZ;
}
break;
case REVERB_DENSITY:
if (length != 1 || index_offset != 0) {
pr_err("REVERB_DENSITY:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
reverb->density = *values++;
pr_debug("%s: REVERB_DENSITY val:%d\n",
__func__, reverb->density);
if (command_config_state == CONFIG_SET) {
*updt_params++ = AUDPROC_MODULE_ID_REVERB;
*updt_params++ =
AUDPROC_PARAM_ID_REVERB_DENSITY;
*updt_params++ = REVERB_DENSITY_PARAM_SZ;
*updt_params++ = reverb->density;
params_length += COMMAND_PAYLOAD_SZ +
REVERB_DENSITY_PARAM_SZ;
}
break;
default:
pr_err("%s: Invalid command to set config\n", __func__);
break;
}
}
if (params_length)
q6asm_send_audio_effects_params(ac, params,
params_length);
invalid_config:
kfree(params);
return rc;
}
int msm_sony_hweffect_sonybundle_handler(struct audio_client *ac,
struct sonybundle_params *sb,
long *values)
{
int devices = *values++;
int num_commands = *values++;
char *params, *effect;
int i, j;
uint32_t module_id, param_id;
int rc = 0;
pr_debug("%s\n", __func__);
if (!ac) {
pr_err("%s: cannot set sonyeffect hw\n", __func__);
return -EINVAL;
}
params = kzalloc(MAX_INBAND_PARAM_SZ, GFP_KERNEL);
if (!params) {
pr_err("%s, params memory alloc failed\n", __func__);
return -ENOMEM;
}
pr_debug("%s: device: %d, num_commands %d\n",
__func__, devices, num_commands);
effect = params + sizeof(struct asm_stream_param_data_v2);
for (i = 0; i < num_commands; i++) {
uint32_t p_length = 0;
uint32_t command_id = *values++;
uint32_t command_config_state = *values++;
uint32_t index_offset = *values++;
uint32_t length = *values++;
switch (command_id) {
case SONYBUNDLE_ENABLE:
if (length != 1 || index_offset != 0) {
pr_err("SONYBUNDLE_ENABLE:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
sb->common.enable_flag = *values++;
pr_debug("%s:SONYBUNDLE_ENABLE state:%d\n", __func__,
sb->common.enable_flag);
if (command_config_state == CONFIG_SET) {
struct common_params *cmn_params =
(struct common_params *)effect;
module_id = ASM_MODULE_ID_SONYBUNDLE;
param_id = PARAM_ID_SB_COMMON_USER_PARAM;
cmn_params->enable_flag =
sb->common.enable_flag;
p_length += sizeof(struct common_params);
}
break;
case DYNAMIC_NORMALIZER_ENABLE:
if (length != 1 || index_offset != 0) {
pr_err("DYNAMIC_NORMALIZER_ENABLE:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
sb->dynamic_normalizer.enable_flag = *values++;
pr_debug("%s:DYNAMIC_NORMALIZER_ENABLE state:%d\n",
__func__, sb->dynamic_normalizer.enable_flag);
if (command_config_state == CONFIG_SET) {
struct dynamic_normalizer_params *dn_params =
(struct dynamic_normalizer_params *)effect;
module_id = ASM_MODULE_ID_SONYBUNDLE;
param_id =
PARAM_ID_SB_DYNAMICNORMALIZER_USER_PARAM;
dn_params->enable_flag =
sb->dynamic_normalizer.enable_flag;
p_length +=
sizeof(struct dynamic_normalizer_params);
}
break;
case SFORCE_ENABLE:
if (length != 1 || index_offset != 0) {
pr_err("SFORCE_ENABLE:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
sb->sforce.enable_flag = *values++;
pr_debug("%s:SFORCE_ENABLE state:%d\n", __func__,
sb->sforce.enable_flag);
if (command_config_state == CONFIG_SET) {
struct sforce_params *sf_params =
(struct sforce_params *)effect;
module_id = ASM_MODULE_ID_SONYBUNDLE;
param_id = PARAM_ID_SB_SFORCE_USER_PARAM;
sf_params->enable_flag =
sb->sforce.enable_flag;
p_length += sizeof(struct sforce_params);
if (!sb->sforce_tuning_update) {
int ret;
ret = sony_hweffect_send_tuning_params(
SFORCE_PARAM,
(void *)ac);
pr_debug("%s:sony_hweffect_send_tuning_params(S-Force) ret=%d\n",
__func__, ret);
if (ret < 0) {
pr_err("SFORCE_ENABLE: send tuning param error\n");
rc = -EINVAL;
goto invalid_config;
}
sb->sforce_tuning_update = true;
}
}
break;
case VPT20_MODE:
if (length != 1 || index_offset != 0) {
pr_err("VPT20_MODE:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
sb->vpt20.mode = *values++;
pr_debug("%s:VPT20_MODE: %d\n", __func__,
sb->vpt20.mode);
if (command_config_state == CONFIG_SET) {
struct vpt20_params *vpt_params =
(struct vpt20_params *)effect;
module_id = ASM_MODULE_ID_SONYBUNDLE;
param_id = PARAM_ID_SB_VPT20_USER_PARAM;
vpt_params->mode = sb->vpt20.mode;
p_length += sizeof(struct vpt20_params);
}
break;
case CLEARPHASE_HP_MODE:
if (length != 1 || index_offset != 0) {
pr_err("CLEARPHASE_HP_MODE:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
sb->clearphase_hp.mode = *values++;
pr_debug("%s:CLEARPHASE_HP_MODE: %d\n", __func__,
sb->clearphase_hp.mode);
if (command_config_state == CONFIG_SET) {
struct clearphase_hp_params *cp_hp_params =
(struct clearphase_hp_params *)effect;
module_id = ASM_MODULE_ID_SONYBUNDLE;
param_id = PARAM_ID_SB_CLEARPHASE_HP_USER_PARAM;
cp_hp_params->mode = sb->clearphase_hp.mode;
p_length += sizeof(struct clearphase_hp_params);
{
int ret;
ret = sony_hweffect_send_tuning_params(
CLEARPHASE_HP_PARAM,
(void *)ac);
pr_debug("%s:sony_hweffect_send_tuning_params(CP_HP) ret=%d\n",
__func__, ret);
if (ret < 0) {
pr_err("CLEARPHASE_HP_MODE: send tuning param error\n");
rc = -EINVAL;
goto invalid_config;
}
}
}
break;
case CLEARAUDIO_CHSEP:
if (length != 1 || index_offset != 0) {
pr_err("CLEARAUDIO_CHSEP:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
sb->clearaudio.chsep_coef = *values++;
pr_debug("%s:CLEARAUDIO_CHSEP: %d\n", __func__,
sb->clearaudio.chsep_coef);
if (command_config_state == CONFIG_SET) {
struct clearaudio_params *ca_params =
(struct clearaudio_params *)effect;
module_id = ASM_MODULE_ID_SONYBUNDLE;
param_id = PARAM_ID_SB_CLEARAUDIO_USER_PARAM;
ca_params->chsep_coef =
sb->clearaudio.chsep_coef;
for (j = 0; j < BAND_NUM; j++)
ca_params->eq_coef[j] =
sb->clearaudio.eq_coef[j];
p_length +=
sizeof(struct clearaudio_params);
}
break;
case CLEARAUDIO_EQ_COEF:
if (length != 6 || index_offset != 0) {
pr_err("CLEARAUDIO_EQ_COEF:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
for (j = 0; j < BAND_NUM; j++)
sb->clearaudio.eq_coef[j] =
(int16_t)*values++;
pr_debug("%s:CLEARAUDIO_EQ_COEF: %d %d %d %d %d %d\n",
__func__,
sb->clearaudio.eq_coef[0],
sb->clearaudio.eq_coef[1],
sb->clearaudio.eq_coef[2],
sb->clearaudio.eq_coef[3],
sb->clearaudio.eq_coef[4],
sb->clearaudio.eq_coef[5]);
if (command_config_state == CONFIG_SET) {
struct clearaudio_params *ca_params =
(struct clearaudio_params *)effect;
module_id = ASM_MODULE_ID_SONYBUNDLE;
param_id = PARAM_ID_SB_CLEARAUDIO_USER_PARAM;
ca_params->chsep_coef =
sb->clearaudio.chsep_coef;
for (j = 0; j < BAND_NUM; j++)
ca_params->eq_coef[j] =
sb->clearaudio.eq_coef[j];
p_length +=
sizeof(struct clearaudio_params);
}
break;
case CLEARAUDIO_VOLUME:
if (length != 1 || index_offset != 0) {
pr_err("CLEARAUDIO_VOLUME:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
sb->ca_volume.gain = *values++;
pr_debug("%s:CLEARAUDIO_VOLUME: %d\n", __func__,
sb->ca_volume.gain);
if (command_config_state == CONFIG_SET) {
struct clearaudio_volume *ca_volume =
(struct clearaudio_volume *)effect;
module_id = ASM_MODULE_ID_SONYBUNDLE;
param_id = PARAM_ID_SB_CLEARAUDIO_VOLUME_PARAM;
ca_volume->gain = sb->ca_volume.gain;
p_length +=
sizeof(struct clearaudio_volume);
}
break;
case CLEARPHASE_SP_ENABLE:
if (length != 1 || index_offset != 0) {
pr_err("CLEARPHASE_SP_ENABLE:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
sb->clearphase_sp.mode = *values++;
pr_debug("%s:CLEARPHASE_SP_ENABLE mode:%d\n", __func__,
sb->clearphase_sp.mode);
if (command_config_state == CONFIG_SET) {
struct clearphase_sp_params *cp_sp_params =
(struct clearphase_sp_params *)effect;
module_id = ASM_MODULE_ID_SONYBUNDLE;
param_id = PARAM_ID_SB_CLEARPHASE_SP_USER_PARAM;
cp_sp_params->mode = sb->clearphase_sp.mode;
p_length +=
sizeof(struct clearphase_sp_params);
if (!sb->clearphase_sp_tuning_update) {
int ret;
ret = sony_hweffect_send_tuning_params(
CLEARPHASE_SP_PARAM,
(void *)ac);
pr_debug("%s:sony_hweffect_send_tuning_params(CP_SP) ret=%d\n",
__func__, ret);
if (ret < 0) {
pr_err("CLEARPHASE_SP_ENABLE: send tuning param error\n");
rc = -EINVAL;
goto invalid_config;
}
sb->clearphase_sp_tuning_update = true;
}
}
break;
case XLOUD_ENABLE:
if (length != 1 || index_offset != 0) {
pr_err("XLOUD_ENABLE:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
sb->xloud.enable_flag = *values++;
pr_debug("%s:XLOUD_ENABLE state:%d\n", __func__,
sb->xloud.enable_flag);
if (command_config_state == CONFIG_SET) {
struct xloud_params *xl_params =
(struct xloud_params *)effect;
module_id = ASM_MODULE_ID_SONYBUNDLE;
param_id = PARAM_ID_SB_XLOUD_USER_PARAM;
xl_params->enable_flag = sb->xloud.enable_flag;
p_length += sizeof(struct xloud_params);
if (!sb->xloud_tuning_update) {
int ret;
ret = sony_hweffect_send_tuning_params(
XLOUD_PARAM,
(void *)ac);
pr_debug("%s:sony_hweffect_send_tuning_params(XLOUD) ret=%d\n",
__func__, ret);
if (ret < 0) {
pr_err("XLOUD_ENABLE: send tuning param error\n");
rc = -EINVAL;
goto invalid_config;
}
sb->xloud_tuning_update = true;
}
}
break;
default:
pr_err("%s: Invalid command to set config\n", __func__);
break;
}
if (p_length) {
struct asm_stream_param_data_v2 *param_data;
int ret;
param_data =
(struct asm_stream_param_data_v2 *)params;
param_data->module_id = module_id;
param_data->param_id = param_id;
param_data->param_size = (uint16_t)p_length;
param_data->reserved = 0;
p_length +=
sizeof(struct asm_stream_param_data_v2);
ret = q6asm_send_audio_effects_params(ac,
params, p_length);
if (ret < 0) {
pr_err("q6asm_send_audio_effects_params "
"failed %d\n", ret);
rc = -EINVAL;
goto invalid_config;
}
}
}
invalid_config:
kfree(params);
return rc;
}
static int __msm_audio_effects_volume_handler(struct audio_client *ac,
struct soft_volume_params *vol,
long *values,
int instance)
{
int devices;
int num_commands;
char *params;
int *updt_params, i;
uint32_t params_length = (MAX_INBAND_PARAM_SZ);
int rc = 0;
pr_debug("%s: instance: %d\n", __func__, instance);
if (!values) {
pr_err("%s: set audio effects failed, no valid data\n",
__func__);
return -EINVAL;
}
if (!ac) {
pr_err("%s: cannot set audio effects as audio client is NULL\n",
__func__);
return -EINVAL;
}
params = kzalloc(params_length, GFP_KERNEL);
if (!params) {
pr_err("%s, params memory alloc failed\n", __func__);
return -ENOMEM;
}
devices = *values++;
num_commands = *values++;
updt_params = (int *)params;
params_length = 0;
for (i = 0; i < num_commands; i++) {
uint32_t command_id = *values++;
uint32_t command_config_state = *values++;
uint32_t index_offset = *values++;
uint32_t length = *values++;
switch (command_id) {
case SOFT_VOLUME_GAIN_2CH:
case SOFT_VOLUME2_GAIN_2CH:
if (length != 2 || index_offset != 0) {
pr_err("VOLUME_GAIN_2CH/VOLUME2_GAIN_2CH:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
vol->left_gain = *values++;
vol->right_gain = *values++;
vol->master_gain = 0x2000;
if (command_config_state == CONFIG_SET) {
if (instance == SOFT_VOLUME_INSTANCE_2)
*updt_params++ =
ASM_MODULE_ID_VOL_CTRL2;
else
*updt_params++ = ASM_MODULE_ID_VOL_CTRL;
*updt_params++ =
ASM_PARAM_ID_VOL_CTRL_LR_CHANNEL_GAIN;
*updt_params++ = SOFT_VOLUME_GAIN_2CH_PARAM_SZ;
*updt_params++ = (vol->left_gain << 16) |
vol->right_gain;
params_length += COMMAND_PAYLOAD_SZ +
SOFT_VOLUME_GAIN_2CH_PARAM_SZ;
if (instance == SOFT_VOLUME_INSTANCE_2)
*updt_params++ =
ASM_MODULE_ID_VOL_CTRL2;
else
*updt_params++ = ASM_MODULE_ID_VOL_CTRL;
*updt_params++ =
ASM_PARAM_ID_VOL_CTRL_MASTER_GAIN;
*updt_params++ =
SOFT_VOLUME_GAIN_MASTER_PARAM_SZ;
*updt_params++ = vol->master_gain;
params_length += COMMAND_PAYLOAD_SZ +
SOFT_VOLUME_GAIN_MASTER_PARAM_SZ;
}
break;
case SOFT_VOLUME_GAIN_MASTER:
case SOFT_VOLUME2_GAIN_MASTER:
if (length != 1 || index_offset != 0) {
pr_err("VOLUME_GAIN_MASTER/VOLUME2_GAIN_MASTER:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
vol->left_gain = 0x2000;
vol->right_gain = 0x2000;
vol->master_gain = *values++;
if (command_config_state == CONFIG_SET) {
if (instance == SOFT_VOLUME_INSTANCE_2)
*updt_params++ =
ASM_MODULE_ID_VOL_CTRL2;
else
*updt_params++ = ASM_MODULE_ID_VOL_CTRL;
*updt_params++ =
ASM_PARAM_ID_VOL_CTRL_LR_CHANNEL_GAIN;
*updt_params++ = SOFT_VOLUME_GAIN_2CH_PARAM_SZ;
*updt_params++ = (vol->left_gain << 16) |
vol->right_gain;
params_length += COMMAND_PAYLOAD_SZ +
SOFT_VOLUME_GAIN_2CH_PARAM_SZ;
if (instance == SOFT_VOLUME_INSTANCE_2)
*updt_params++ =
ASM_MODULE_ID_VOL_CTRL2;
else
*updt_params++ = ASM_MODULE_ID_VOL_CTRL;
*updt_params++ =
ASM_PARAM_ID_VOL_CTRL_MASTER_GAIN;
*updt_params++ =
SOFT_VOLUME_GAIN_MASTER_PARAM_SZ;
*updt_params++ = vol->master_gain;
params_length += COMMAND_PAYLOAD_SZ +
SOFT_VOLUME_GAIN_MASTER_PARAM_SZ;
}
break;
default:
pr_err("%s: Invalid command id: %d to set config\n",
__func__, command_id);
break;
}
}
if (params_length)
q6asm_send_audio_effects_params(ac, params,
params_length);
invalid_config:
kfree(params);
return rc;
}
int msm_audio_effects_bass_boost_handler(struct audio_client *ac,
struct bass_boost_params *bass_boost,
long *values)
{
long *param_max_offset = values + MAX_PP_PARAMS_SZ - 1;
char *params = NULL;
int rc = 0;
int devices = GET_NEXT(values, param_max_offset, rc);
int num_commands = GET_NEXT(values, param_max_offset, rc);
int *updt_params, i, prev_enable_flag;
uint32_t params_length = (MAX_INBAND_PARAM_SZ);
pr_debug("%s\n", __func__);
if (!ac || (devices == -EINVAL) || (num_commands == -EINVAL)) {
pr_err("%s: cannot set audio effects\n", __func__);
return -EINVAL;
}
params = kzalloc(params_length, GFP_KERNEL);
if (!params) {
pr_err("%s, params memory alloc failed\n", __func__);
return -ENOMEM;
}
pr_debug("%s: device: %d\n", __func__, devices);
updt_params = (int *)params;
params_length = 0;
for (i = 0; i < num_commands; i++) {
uint32_t command_id =
GET_NEXT(values, param_max_offset, rc);
uint32_t command_config_state =
GET_NEXT(values, param_max_offset, rc);
uint32_t index_offset =
GET_NEXT(values, param_max_offset, rc);
uint32_t length =
GET_NEXT(values, param_max_offset, rc);
switch (command_id) {
case BASS_BOOST_ENABLE:
if (length != 1 || index_offset != 0) {
pr_err("BASS_BOOST_ENABLE:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
prev_enable_flag = bass_boost->enable_flag;
bass_boost->enable_flag =
GET_NEXT(values, param_max_offset, rc);
pr_debug("%s: BASS_BOOST_ENABLE prev:%d new:%d\n",
__func__, prev_enable_flag,
bass_boost->enable_flag);
if (prev_enable_flag != bass_boost->enable_flag) {
params_length += COMMAND_PAYLOAD_SZ +
BASS_BOOST_ENABLE_PARAM_SZ;
CHECK_PARAM_LEN(params_length,
MAX_INBAND_PARAM_SZ,
"BASS_BOOST_ENABLE", rc);
if (rc != 0)
break;
*updt_params++ =
AUDPROC_MODULE_ID_BASS_BOOST;
*updt_params++ =
AUDPROC_PARAM_ID_BASS_BOOST_ENABLE;
*updt_params++ =
BASS_BOOST_ENABLE_PARAM_SZ;
*updt_params++ =
bass_boost->enable_flag;
}
break;
case BASS_BOOST_MODE:
if (length != 1 || index_offset != 0) {
pr_err("BASS_BOOST_MODE:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
bass_boost->mode =
GET_NEXT(values, param_max_offset, rc);
pr_debug("%s: BASS_BOOST_MODE val:%d\n",
__func__, bass_boost->mode);
if (command_config_state == CONFIG_SET) {
params_length += COMMAND_PAYLOAD_SZ +
BASS_BOOST_MODE_PARAM_SZ;
CHECK_PARAM_LEN(params_length,
MAX_INBAND_PARAM_SZ,
"BASS_BOOST_MODE", rc);
if (rc != 0)
break;
*updt_params++ =
AUDPROC_MODULE_ID_BASS_BOOST;
*updt_params++ =
AUDPROC_PARAM_ID_BASS_BOOST_MODE;
*updt_params++ =
BASS_BOOST_MODE_PARAM_SZ;
*updt_params++ =
bass_boost->mode;
}
break;
case BASS_BOOST_STRENGTH:
if (length != 1 || index_offset != 0) {
pr_err("BASS_BOOST_STRENGTH:invalid params\n");
rc = -EINVAL;
goto invalid_config;
}
bass_boost->strength =
GET_NEXT(values, param_max_offset, rc);
pr_debug("%s: BASS_BOOST_STRENGTH val:%d\n",
__func__, bass_boost->strength);
if (command_config_state == CONFIG_SET) {
params_length += COMMAND_PAYLOAD_SZ +
BASS_BOOST_STRENGTH_PARAM_SZ;
CHECK_PARAM_LEN(params_length,
MAX_INBAND_PARAM_SZ,
"BASS_BOOST_STRENGTH", rc);
if (rc != 0)
break;
*updt_params++ =
AUDPROC_MODULE_ID_BASS_BOOST;
*updt_params++ =
AUDPROC_PARAM_ID_BASS_BOOST_STRENGTH;
*updt_params++ =
BASS_BOOST_STRENGTH_PARAM_SZ;
*updt_params++ =
bass_boost->strength;
}
break;
default:
pr_err("%s: Invalid command to set config\n", __func__);
break;
}
}
if (params_length && !msm_dts_eagle_is_hpx_on() && (rc == 0))
q6asm_send_audio_effects_params(ac, params,
params_length);
else
pr_debug("%s: did not send pp params\n", __func__);
invalid_config:
kfree(params);
return rc;
}