static long audio_ioctl_shared(struct file *file, unsigned int cmd,
void *arg)
{
struct q6audio_aio *audio = file->private_data;
int rc = 0;
switch (cmd) {
case AUDIO_START: {
struct asm_wma_cfg wma_cfg;
struct msm_audio_wma_config_v2 *wma_config;
pr_debug("%s[%p]: AUDIO_START session_id[%d]\n", __func__,
audio, audio->ac->session);
if (audio->feedback == NON_TUNNEL_MODE) {
/* Configure PCM output block */
rc = q6asm_enc_cfg_blk_pcm(audio->ac,
audio->pcm_cfg.sample_rate,
audio->pcm_cfg.channel_count);
if (rc < 0) {
pr_err("pcm output block config failed\n");
break;
}
}
wma_config = (struct msm_audio_wma_config_v2 *)audio->codec_cfg;
wma_cfg.format_tag = wma_config->format_tag;
wma_cfg.ch_cfg = wma_config->numchannels;
wma_cfg.sample_rate = wma_config->samplingrate;
wma_cfg.avg_bytes_per_sec = wma_config->avgbytespersecond;
wma_cfg.block_align = wma_config->block_align;
wma_cfg.valid_bits_per_sample =
wma_config->validbitspersample;
wma_cfg.ch_mask = wma_config->channelmask;
wma_cfg.encode_opt = wma_config->encodeopt;
/* Configure Media format block */
rc = q6asm_media_format_block_wma(audio->ac, &wma_cfg,
audio->ac->stream_id);
if (rc < 0) {
pr_err("cmd media format block failed\n");
break;
}
rc = audio_aio_enable(audio);
audio->eos_rsp = 0;
audio->eos_flag = 0;
if (!rc) {
audio->enabled = 1;
} else {
audio->enabled = 0;
pr_err("Audio Start procedure failed rc=%d\n", rc);
break;
}
pr_debug("AUDIO_START success enable[%d]\n", audio->enabled);
if (audio->stopped == 1)
audio->stopped = 0;
break;
}
default:
pr_err("%s: Unknown ioctl cmd = %d", __func__, cmd);
break;
}
return rc;
}
static long audio_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct q6audio_aio *audio = file->private_data;
int rc = 0;
switch (cmd) {
case AUDIO_START: {
pr_debug("%s[%p]: AUDIO_START session_id[%d]\n", __func__,
audio, audio->ac->session);
if (audio->feedback == NON_TUNNEL_MODE) {
/* Configure PCM output block */
rc = q6asm_enc_cfg_blk_pcm(audio->ac,
audio->pcm_cfg.sample_rate,
audio->pcm_cfg.channel_count);
if (rc < 0) {
pr_err("pcm output block config failed\n");
break;
}
}
rc = audio_aio_enable(audio);
audio->eos_rsp = 0;
audio->eos_flag = 0;
if (!rc) {
rc = enable_volume_ramp(audio);
if (rc < 0) {
pr_err("%s: Failed to enable volume ramp\n",
__func__);
}
audio->enabled = 1;
} else {
audio->enabled = 0;
pr_err("Audio Start procedure failed rc=%d\n", rc);
break;
}
pr_info("%s: AUDIO_START sessionid[%d]enable[%d]\n", __func__,
audio->ac->session,
audio->enabled);
if (audio->stopped == 1)
audio->stopped = 0;
break;
}
default:
pr_debug("%s[%p]: Calling utils ioctl\n", __func__, audio);
rc = audio->codec_ioctl(file, cmd, arg);
}
return rc;
}
static long audio_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct q6audio_aio *audio = file->private_data;
int rc = 0;
switch (cmd) {
case AUDIO_START: {
struct asm_wma_cfg wma_cfg;
struct msm_audio_wma_config_v2 *wma_config;
pr_debug("%s[%p]: AUDIO_START session_id[%d]\n", __func__,
audio, audio->ac->session);
if (audio->feedback == NON_TUNNEL_MODE) {
rc = q6asm_enc_cfg_blk_pcm(audio->ac,
audio->pcm_cfg.sample_rate,
audio->pcm_cfg.channel_count);
if (rc < 0) {
pr_err("pcm output block config failed\n");
break;
}
}
wma_config = (struct msm_audio_wma_config_v2 *)audio->codec_cfg;
wma_cfg.format_tag = wma_config->format_tag;
wma_cfg.ch_cfg = wma_config->numchannels;
wma_cfg.sample_rate = wma_config->samplingrate;
wma_cfg.avg_bytes_per_sec = wma_config->avgbytespersecond;
wma_cfg.block_align = wma_config->block_align;
wma_cfg.valid_bits_per_sample =
wma_config->validbitspersample;
wma_cfg.ch_mask = wma_config->channelmask;
wma_cfg.encode_opt = wma_config->encodeopt;
rc = q6asm_media_format_block_wma(audio->ac, &wma_cfg);
if (rc < 0) {
pr_err("cmd media format block failed\n");
break;
}
rc = audio_aio_enable(audio);
audio->eos_rsp = 0;
audio->eos_flag = 0;
if (!rc) {
audio->enabled = 1;
} else {
audio->enabled = 0;
pr_err("Audio Start procedure failed rc=%d\n", rc);
break;
}
pr_debug("AUDIO_START success enable[%d]\n", audio->enabled);
if (audio->stopped == 1)
audio->stopped = 0;
break;
}
case AUDIO_GET_WMA_CONFIG_V2: {
if (copy_to_user((void *)arg, audio->codec_cfg,
sizeof(struct msm_audio_wma_config_v2))) {
rc = -EFAULT;
break;
}
break;
}
case AUDIO_SET_WMA_CONFIG_V2: {
if (copy_from_user(audio->codec_cfg, (void *)arg,
sizeof(struct msm_audio_wma_config_v2))) {
rc = -EFAULT;
break;
}
break;
}
default:
pr_debug("%s[%p]: Calling utils ioctl\n", __func__, audio);
rc = audio->codec_ioctl(file, cmd, arg);
if (rc)
pr_err("Failed in utils_ioctl: %d\n", rc);
}
return rc;
}
static long audio_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct q6audio_aio *audio = file->private_data;
int rc = 0;
switch (cmd) {
case AUDIO_START: {
struct asm_aac_cfg aac_cfg;
struct msm_audio_aac_config *aac_config;
uint32_t sbr_ps = 0x00;
pr_debug("%s: AUDIO_START session_id[%d]\n", __func__,
audio->ac->session);
if (audio->feedback == NON_TUNNEL_MODE) {
/* Configure PCM output block */
rc = q6asm_enc_cfg_blk_pcm(audio->ac,
0, /*native sampling rate*/
0 /*native channel count*/);
if (rc < 0) {
pr_err("pcm output block config failed\n");
break;
}
}
/* turn on both sbr and ps */
rc = q6asm_enable_sbrps(audio->ac, sbr_ps);
if (rc < 0)
pr_err("sbr-ps enable failed\n");
aac_config = (struct msm_audio_aac_config *)audio->codec_cfg;
if (aac_config->sbr_ps_on_flag)
aac_cfg.aot = AAC_ENC_MODE_EAAC_P;
else if (aac_config->sbr_on_flag)
aac_cfg.aot = AAC_ENC_MODE_AAC_P;
else
aac_cfg.aot = AAC_ENC_MODE_AAC_LC;
switch (aac_config->format) {
case AUDIO_AAC_FORMAT_ADTS:
aac_cfg.format = 0x00;
break;
case AUDIO_AAC_FORMAT_LOAS:
aac_cfg.format = 0x01;
break;
case AUDIO_AAC_FORMAT_ADIF:
aac_cfg.format = 0x02;
break;
default:
case AUDIO_AAC_FORMAT_RAW:
aac_cfg.format = 0x03;
}
aac_cfg.ep_config = aac_config->ep_config;
aac_cfg.section_data_resilience =
aac_config->aac_section_data_resilience_flag;
aac_cfg.scalefactor_data_resilience =
aac_config->aac_scalefactor_data_resilience_flag;
aac_cfg.spectral_data_resilience =
aac_config->aac_spectral_data_resilience_flag;
aac_cfg.ch_cfg = aac_config->channel_configuration;
aac_cfg.sample_rate = audio->pcm_cfg.sample_rate;
pr_debug("%s:format=%x aot=%d ch=%d sr=%d\n",
__func__, aac_cfg.format,
aac_cfg.aot, aac_cfg.ch_cfg,
aac_cfg.sample_rate);
/* Configure Media format block */
rc = q6asm_media_format_block_multi_aac(audio->ac, &aac_cfg);
if (rc < 0) {
pr_err("cmd media format block failed\n");
break;
}
if (!cpu_is_msm8x60()) {
rc = q6asm_set_encdec_chan_map(audio->ac, 2);
if (rc < 0) {
pr_err("%s: cmd set encdec_chan_map failed\n",
__func__);
break;
}
}
rc = audio_aio_enable(audio);
audio->eos_rsp = 0;
audio->eos_flag = 0;
if (!rc) {
audio->enabled = 1;
} else {
audio->enabled = 0;
pr_err("Audio Start procedure failed rc=%d\n", rc);
break;
}
pr_info("%s: AUDIO_START sessionid[%d]enable[%d]\n", __func__,
audio->ac->session,
audio->enabled);
if (audio->stopped == 1)
audio->stopped = 0;
break;
}
case AUDIO_GET_AAC_CONFIG: {
if (copy_to_user((void *)arg, audio->codec_cfg,
sizeof(struct msm_audio_aac_config))) {
rc = -EFAULT;
break;
}
break;
}
case AUDIO_SET_AAC_CONFIG: {
struct msm_audio_aac_config *aac_config;
if (copy_from_user(audio->codec_cfg, (void *)arg,
sizeof(struct msm_audio_aac_config))) {
rc = -EFAULT;
} else {
uint16_t sce_left = 1, sce_right = 2;
aac_config = audio->codec_cfg;
if (aac_config->dual_mono_mode >
AUDIO_AAC_DUAL_MONO_PL_SR) {
pr_err("%s:AUDIO_SET_AAC_CONFIG: Invalid"
"dual_mono mode =%d\n", __func__,
aac_config->dual_mono_mode);
} else {
/* convert the data from user into sce_left
* and sce_right based on the definitions
*/
pr_debug("%s: AUDIO_SET_AAC_CONFIG: modify"
"dual_mono mode =%d\n", __func__,
aac_config->dual_mono_mode);
switch (aac_config->dual_mono_mode) {
case AUDIO_AAC_DUAL_MONO_PL_PR:
sce_left = 1;
sce_right = 1;
break;
case AUDIO_AAC_DUAL_MONO_SL_SR:
sce_left = 2;
sce_right = 2;
break;
case AUDIO_AAC_DUAL_MONO_SL_PR:
sce_left = 2;
sce_right = 1;
break;
case AUDIO_AAC_DUAL_MONO_PL_SR:
default:
sce_left = 1;
sce_right = 2;
break;
}
rc = q6asm_cfg_dual_mono_aac(audio->ac,
sce_left, sce_right);
if (rc < 0)
pr_err("%s: asm cmd dualmono failed"
" rc=%d\n", __func__, rc);
} break;
}
break;
}
default:
pr_debug("Calling utils ioctl\n");
rc = audio->codec_ioctl(file, cmd, arg);
}
return rc;
}
static long audio_ioctl_shared(struct file *file, unsigned int cmd,
void *arg)
{
struct q6audio_aio *audio = file->private_data;
int rc = 0;
switch (cmd) {
case AUDIO_START: {
struct asm_alac_cfg alac_cfg;
struct msm_audio_alac_config *alac_config;
pr_debug("%s[%p]: AUDIO_START session_id[%d]\n", __func__,
audio, audio->ac->session);
if (audio->feedback == NON_TUNNEL_MODE) {
/* Configure PCM output block */
rc = q6asm_enc_cfg_blk_pcm(audio->ac,
audio->pcm_cfg.sample_rate,
audio->pcm_cfg.channel_count);
if (rc < 0) {
pr_err("pcm output block config failed\n");
break;
}
}
alac_config = (struct msm_audio_alac_config *)audio->codec_cfg;
alac_cfg.frame_length = alac_config->frameLength;
alac_cfg.compatible_version = alac_config->compatVersion;
alac_cfg.bit_depth = alac_config->bitDepth;
alac_cfg.pb = alac_config->pb;
alac_cfg.mb = alac_config->mb;
alac_cfg.kb = alac_config->kb;
alac_cfg.num_channels = alac_config->channelCount;
alac_cfg.max_run = alac_config->maxRun;
alac_cfg.max_frame_bytes = alac_config->maxSize;
alac_cfg.avg_bit_rate = alac_config->averageBitRate;
alac_cfg.sample_rate = alac_config->sampleRate;
alac_cfg.channel_layout_tag = alac_config->channelLayout;
pr_debug("%s: frame_length %d compatible_version %d bit_depth %d pb %d mb %d kb %d num_channels %d max_run %d max_frame_bytes %d avg_bit_rate %d sample_rate %d channel_layout_tag %d\n",
__func__, alac_config->frameLength,
alac_config->compatVersion,
alac_config->bitDepth, alac_config->pb,
alac_config->mb, alac_config->kb,
alac_config->channelCount, alac_config->maxRun,
alac_config->maxSize,
alac_config->averageBitRate,
alac_config->sampleRate,
alac_config->channelLayout);
/* Configure Media format block */
rc = q6asm_media_format_block_alac(audio->ac, &alac_cfg,
audio->ac->stream_id);
if (rc < 0) {
pr_err("cmd media format block failed\n");
break;
}
rc = audio_aio_enable(audio);
audio->eos_rsp = 0;
audio->eos_flag = 0;
if (!rc) {
audio->enabled = 1;
} else {
audio->enabled = 0;
pr_err("Audio Start procedure failed rc=%d\n", rc);
break;
}
pr_debug("AUDIO_START success enable[%d]\n", audio->enabled);
if (audio->stopped == 1)
audio->stopped = 0;
break;
}
default:
pr_err("%s: Unknown ioctl cmd = %d", __func__, cmd);
break;
}
return rc;
}
static long audio_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct asm_amrwbplus_cfg q6_amrwbplus_cfg;
struct msm_audio_amrwbplus_config_v2 *amrwbplus_drv_config;
struct q6audio_aio *audio = file->private_data;
int rc = 0;
switch (cmd) {
case AUDIO_START: {
pr_err("%s[%p]: AUDIO_START session_id[%d]\n", __func__,
audio, audio->ac->session);
if (audio->feedback == NON_TUNNEL_MODE) {
/* Configure PCM output block */
rc = q6asm_enc_cfg_blk_pcm(audio->ac,
audio->pcm_cfg.sample_rate,
audio->pcm_cfg.channel_count);
if (rc < 0) {
pr_err("pcm output block config failed\n");
break;
}
}
amrwbplus_drv_config =
(struct msm_audio_amrwbplus_config_v2 *)audio->codec_cfg;
q6_amrwbplus_cfg.size_bytes =
amrwbplus_drv_config->size_bytes;
q6_amrwbplus_cfg.version =
amrwbplus_drv_config->version;
q6_amrwbplus_cfg.num_channels =
amrwbplus_drv_config->num_channels;
q6_amrwbplus_cfg.amr_band_mode =
amrwbplus_drv_config->amr_band_mode;
q6_amrwbplus_cfg.amr_dtx_mode =
amrwbplus_drv_config->amr_dtx_mode;
q6_amrwbplus_cfg.amr_frame_fmt =
amrwbplus_drv_config->amr_frame_fmt;
q6_amrwbplus_cfg.amr_lsf_idx =
amrwbplus_drv_config->amr_lsf_idx;
rc = q6asm_media_format_block_amrwbplus(audio->ac,
&q6_amrwbplus_cfg);
if (rc < 0) {
pr_err("q6asm_media_format_block_amrwb+ failed...\n");
break;
}
rc = audio_aio_enable(audio);
audio->eos_rsp = 0;
audio->eos_flag = 0;
if (!rc) {
audio->enabled = 1;
} else {
audio->enabled = 0;
pr_err("Audio Start procedure failed rc=%d\n", rc);
break;
}
pr_debug("%s:AUDIO_START sessionid[%d]enable[%d]\n", __func__,
audio->ac->session,
audio->enabled);
if (audio->stopped == 1)
audio->stopped = 0;
break;
}
case AUDIO_GET_AMRWBPLUS_CONFIG_V2: {
if ((audio) && (arg) && (audio->codec_cfg)) {
if (copy_to_user((void *)arg, audio->codec_cfg,
sizeof(struct msm_audio_amrwbplus_config_v2))) {
rc = -EFAULT;
pr_err("wb+ config get copy_to_user failed");
break;
}
} else {
pr_err("wb+ config v2 invalid parameters..");
rc = -EFAULT;
break;
}
break;
}
case AUDIO_SET_AMRWBPLUS_CONFIG_V2: {
if ((audio) && (arg) && (audio->codec_cfg)) {
if (copy_from_user(audio->codec_cfg, (void *)arg,
sizeof(struct msm_audio_amrwbplus_config_v2))) {
rc = -EFAULT;
pr_err("wb+ config set copy_to_user_failed");
break;
}
} else {
pr_err("wb+ config invalid parameters..");
rc = -EFAULT;
break;
}
break;
}
default:
pr_debug("%s[%p]: Calling utils ioctl\n", __func__, audio);
rc = audio->codec_ioctl(file, cmd, arg);
}
return rc;
}
static int config(struct pcm *pcm)
{
int rc = 0;
pr_debug("%s: pcm prefill, buffer_size = %d\n", __func__,
pcm->buffer_size);
rc = q6asm_audio_client_buf_alloc(OUT, pcm->ac,
pcm->buffer_size, pcm->buffer_count);
if (rc < 0) {
pr_aud_err("Audio Start: Buffer Allocation failed \
rc = %d\n", rc);
goto fail;
}
rc = q6asm_enc_cfg_blk_pcm(pcm->ac, pcm->sample_rate,
pcm->channel_count);
if (rc < 0) {
pr_aud_err("%s: cmd media format block failed", __func__);
goto fail;
}
fail:
return rc;
}
static long pcm_in_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct pcm *pcm = file->private_data;
int rc = 0;
mutex_lock(&pcm->lock);
switch (cmd) {
static long audio_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct q6audio_aio *audio = file->private_data;
int rc = 0;
switch (cmd) {
case AUDIO_START: {
pr_debug("%s[%p]: AUDIO_START session_id[%d]\n", __func__,
audio, audio->ac->session);
if (audio->feedback == NON_TUNNEL_MODE) {
/* Configure PCM output block */
rc = q6asm_enc_cfg_blk_pcm(audio->ac,
audio->pcm_cfg.sample_rate,
audio->pcm_cfg.channel_count);
if (rc < 0) {
pr_err("pcm output block config failed\n");
break;
}
}
rc = audio_aio_enable(audio);
audio->eos_rsp = 0;
audio->eos_flag = 0;
if (!rc) {
audio->enabled = 1;
} else {
audio->enabled = 0;
pr_err("Audio Start procedure failed rc=%d\n", rc);
break;
}
pr_info("%s: AUDIO_START sessionid[%d]enable[%d]\n", __func__,
audio->ac->session,
audio->enabled);
if (audio->stopped == 1)
audio->stopped = 0;
break;
}
case AUDIO_SET_Q6_EFFECT: {
struct param {
uint32_t effect_type; /* 0 for POPP, 1 for COPP */
uint32_t module_id;
uint32_t param_id;
uint32_t payload_size;
} q6_param;
void *payload;
pr_aud_info("AUDIO_SET_Q6_EFFECT, session %d ++++\n", audio->ac->session);
if (copy_from_user(&q6_param, (void *) arg,
sizeof(q6_param))) {
pr_aud_err("%s: copy param from user failed\n",
__func__);
rc = -EFAULT;
break;
}
if (q6_param.payload_size <= 0 ||
(q6_param.effect_type != 0 &&
q6_param.effect_type != 1)) {
pr_aud_err("%s: unsupported param: %d, 0x%x, 0x%x, %d\n",
__func__, q6_param.effect_type,
q6_param.module_id, q6_param.param_id,
q6_param.payload_size);
rc = -EINVAL;
break;
}
payload = kzalloc(q6_param.payload_size, GFP_KERNEL);
if (!payload) {
pr_aud_err("%s: failed to allocate memory\n",
__func__);
rc = -ENOMEM;
break;
}
if (copy_from_user(payload, (void *) (arg + sizeof(q6_param)),
q6_param.payload_size)) {
pr_aud_err("%s: copy payload from user failed\n",
__func__);
kfree(payload);
rc = -EFAULT;
break;;
}
if (q6_param.effect_type == 0) { /* POPP */
rc = q6asm_enable_effect(audio->ac,
q6_param.module_id,
q6_param.param_id,
q6_param.payload_size,
payload);
pr_aud_info("q6asm_enable_effect, return %d (session %d)\n", rc, audio->ac->session);
}
#if Q6_EFFECT_DEBUG
{
int *ptr;
int i;
ptr = (int *)payload;
for (i = 0; i < (q6_param.payload_size / 4); i++)
pr_aud_info("0x%08x", *(ptr + i));
}
#endif
kfree(payload);
pr_aud_info("AUDIO_SET_Q6_EFFECT, session %d ---\n", audio->ac->session);
break;
}
default:
/* pr_debug("%s[%p]: Calling utils ioctl\n", __func__, audio); */
rc = audio->codec_ioctl(file, cmd, arg);
}
return rc;
}
static long audio_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct q6audio_aio *audio = file->private_data;
int rc = 0;
switch (cmd) {
case AUDIO_START: {
struct asm_wmapro_cfg wmapro_cfg;
struct msm_audio_wmapro_config *wmapro_config;
pr_debug("%s: AUDIO_START session_id[%d]\n", __func__,
audio->ac->session);
if (audio->feedback == NON_TUNNEL_MODE) {
rc = q6asm_enc_cfg_blk_pcm(audio->ac,
audio->pcm_cfg.sample_rate,
audio->pcm_cfg.channel_count);
if (rc < 0) {
pr_err("pcm output block config failed\n");
break;
}
}
wmapro_config = (struct msm_audio_wmapro_config *)
audio->codec_cfg;
if ((wmapro_config->formattag == 0x162) ||
(wmapro_config->formattag == 0x163) ||
(wmapro_config->formattag == 0x166) ||
(wmapro_config->formattag == 0x167)) {
wmapro_cfg.format_tag = wmapro_config->formattag;
} else {
pr_err("%s:AUDIO_START failed: formattag = %d\n",
__func__, wmapro_config->formattag);
rc = -EINVAL;
break;
}
if ((wmapro_config->numchannels == 1) ||
(wmapro_config->numchannels == 2)) {
wmapro_cfg.ch_cfg = wmapro_config->numchannels;
} else {
pr_err("%s:AUDIO_START failed: channels = %d\n",
__func__, wmapro_config->numchannels);
rc = -EINVAL;
break;
}
if ((wmapro_config->samplingrate <= 48000) ||
(wmapro_config->samplingrate > 0)) {
wmapro_cfg.sample_rate =
wmapro_config->samplingrate;
} else {
pr_err("%s:AUDIO_START failed: sample_rate = %d\n",
__func__, wmapro_config->samplingrate);
rc = -EINVAL;
break;
}
wmapro_cfg.avg_bytes_per_sec =
wmapro_config->avgbytespersecond;
if ((wmapro_config->asfpacketlength <= 13376) ||
(wmapro_config->asfpacketlength > 0)) {
wmapro_cfg.block_align =
wmapro_config->asfpacketlength;
} else {
pr_err("%s:AUDIO_START failed: block_align = %d\n",
__func__, wmapro_config->asfpacketlength);
rc = -EINVAL;
break;
}
if ((wmapro_config->validbitspersample == 16) ||
(wmapro_config->validbitspersample == 24)) {
wmapro_cfg.valid_bits_per_sample =
wmapro_config->validbitspersample;
} else {
pr_err("%s:AUDIO_START failed: bitspersample = %d\n",
__func__,
wmapro_config->validbitspersample);
rc = -EINVAL;
break;
}
if ((wmapro_config->channelmask == 4) ||
(wmapro_config->channelmask == 3)) {
wmapro_cfg.ch_mask = wmapro_config->channelmask;
} else {
pr_err("%s:AUDIO_START failed: channel_mask = %d\n",
__func__, wmapro_config->channelmask);
rc = -EINVAL;
break;
}
wmapro_cfg.encode_opt = wmapro_config->encodeopt;
wmapro_cfg.adv_encode_opt =
wmapro_config->advancedencodeopt;
wmapro_cfg.adv_encode_opt2 =
wmapro_config->advancedencodeopt2;
rc = q6asm_media_format_block_wmapro(audio->ac, &wmapro_cfg);
if (rc < 0) {
pr_err("cmd media format block failed\n");
break;
}
rc = audio_aio_enable(audio);
audio->eos_rsp = 0;
audio->eos_flag = 0;
if (!rc) {
audio->enabled = 1;
} else {
audio->enabled = 0;
pr_err("Audio Start procedure failed rc=%d\n", rc);
break;
}
pr_debug("AUDIO_START success enable[%d]\n", audio->enabled);
if (audio->stopped == 1)
audio->stopped = 0;
break;
}
case AUDIO_GET_WMAPRO_CONFIG: {
if (copy_to_user((void *)arg, audio->codec_cfg,
sizeof(struct msm_audio_wmapro_config))) {
rc = -EFAULT;
}
break;
}
case AUDIO_SET_WMAPRO_CONFIG: {
if (copy_from_user(audio->codec_cfg, (void *)arg,
sizeof(struct msm_audio_wmapro_config))) {
rc = -EFAULT;
break;
}
break;
}
default:
pr_debug("%s[%p]: Calling utils ioctl\n", __func__, audio);
rc = audio->codec_ioctl(file, cmd, arg);
if (rc)
pr_err("Failed in utils_ioctl: %d\n", rc);
}
return rc;
}
static long audio_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct q6audio_aio *audio = file->private_data;
int rc = 0;
switch (cmd) {
case AUDIO_START: {
struct asm_aac_cfg aac_cfg;
struct msm_audio_aac_config *aac_config;
uint32_t sbr_ps = 0x00;
pr_debug("%s: AUDIO_START session_id[%d]\n", __func__,
audio->ac->session);
if (audio->feedback == NON_TUNNEL_MODE) {
rc = q6asm_enc_cfg_blk_pcm(audio->ac, 0, 0);
if (rc < 0) {
pr_err("pcm output block config failed\n");
break;
}
}
rc = q6asm_enable_sbrps(audio->ac, sbr_ps);
if (rc < 0)
pr_err("sbr-ps enable failed\n");
aac_config = (struct msm_audio_aac_config *)audio->codec_cfg;
if (aac_config->sbr_ps_on_flag)
aac_cfg.aot = AAC_ENC_MODE_EAAC_P;
else if (aac_config->sbr_on_flag)
aac_cfg.aot = AAC_ENC_MODE_AAC_P;
else
aac_cfg.aot = AAC_ENC_MODE_AAC_LC;
switch (aac_config->format) {
case AUDIO_AAC_FORMAT_ADTS:
aac_cfg.format = 0x00;
break;
case AUDIO_AAC_FORMAT_LOAS:
aac_cfg.format = 0x01;
break;
case AUDIO_AAC_FORMAT_ADIF:
aac_cfg.format = 0x02;
break;
default:
case AUDIO_AAC_FORMAT_RAW:
aac_cfg.format = 0x03;
}
aac_cfg.ep_config = aac_config->ep_config;
aac_cfg.section_data_resilience =
aac_config->aac_section_data_resilience_flag;
aac_cfg.scalefactor_data_resilience =
aac_config->aac_scalefactor_data_resilience_flag;
aac_cfg.spectral_data_resilience =
aac_config->aac_spectral_data_resilience_flag;
aac_cfg.ch_cfg = audio->pcm_cfg.channel_count;
if (audio->feedback == TUNNEL_MODE) {
aac_cfg.sample_rate = aac_config->sample_rate;
aac_cfg.ch_cfg = aac_config->channel_configuration;
} else {
aac_cfg.sample_rate = audio->pcm_cfg.sample_rate;
aac_cfg.ch_cfg = audio->pcm_cfg.channel_count;
}
pr_debug("%s:format=%x aot=%d ch=%d sr=%d\n",
__func__, aac_cfg.format,
aac_cfg.aot, aac_cfg.ch_cfg,
aac_cfg.sample_rate);
rc = q6asm_media_format_block_aac(audio->ac, &aac_cfg);
if (rc < 0) {
pr_err("cmd media format block failed\n");
break;
}
rc = audio_aio_enable(audio);
audio->eos_rsp = 0;
audio->eos_flag = 0;
if (!rc) {
audio->enabled = 1;
} else {
audio->enabled = 0;
pr_err("Audio Start procedure failed rc=%d\n", rc);
break;
}
pr_info("%s: AUDIO_START sessionid[%d]enable[%d]\n", __func__,
audio->ac->session,
audio->enabled);
if (audio->stopped == 1)
audio->stopped = 0;
break;
}
case AUDIO_GET_AAC_CONFIG: {
if (copy_to_user((void *)arg, audio->codec_cfg,
sizeof(struct msm_audio_aac_config))) {
rc = -EFAULT;
break;
}
break;
}
case AUDIO_SET_AAC_CONFIG: {
struct msm_audio_aac_config *aac_config;
pr_debug("%s: AUDIO_SET_AAC_CONFIG\n", __func__);
if (copy_from_user(audio->codec_cfg, (void *)arg,
sizeof(struct msm_audio_aac_config))) {
rc = -EFAULT;
break;
} else {
uint16_t sce_left = 1, sce_right = 2;
aac_config = audio->codec_cfg;
if (aac_config->dual_mono_mode >
AUDIO_AAC_DUAL_MONO_PL_SR) {
pr_err("%s:AUDIO_SET_AAC_CONFIG: Invalid"
"dual_mono mode =%d\n", __func__,
aac_config->dual_mono_mode);
} else {
pr_debug("%s: AUDIO_SET_AAC_CONFIG: modify"
"dual_mono mode =%d\n", __func__,
aac_config->dual_mono_mode);
switch (aac_config->dual_mono_mode) {
case AUDIO_AAC_DUAL_MONO_PL_PR:
sce_left = 1;
sce_right = 1;
break;
case AUDIO_AAC_DUAL_MONO_SL_SR:
sce_left = 2;
sce_right = 2;
break;
case AUDIO_AAC_DUAL_MONO_SL_PR:
sce_left = 2;
sce_right = 1;
break;
case AUDIO_AAC_DUAL_MONO_PL_SR:
default:
sce_left = 1;
sce_right = 2;
break;
}
rc = q6asm_cfg_dual_mono_aac(audio->ac,
sce_left, sce_right);
if (rc < 0)
pr_err("%s: asm cmd dualmono failed"
" rc=%d\n", __func__, rc);
}
}
break;
}
case AUDIO_SET_Q6_EFFECT: {
struct param {
uint32_t effect_type;
uint32_t module_id;
uint32_t param_id;
uint32_t payload_size;
} q6_param;
void *payload;
pr_aud_info("AUDIO_SET_Q6_EFFECT, session %d ++++\n", audio->ac->session);
if (copy_from_user(&q6_param, (void *) arg,
sizeof(q6_param))) {
pr_aud_err("%s: copy param from user failed\n",
__func__);
rc = -EFAULT;
break;
}
if (q6_param.payload_size <= 0 ||
(q6_param.effect_type != 0 &&
q6_param.effect_type != 1)) {
pr_aud_err("%s: unsupported param: %d, 0x%x, 0x%x, %d\n",
__func__, q6_param.effect_type,
q6_param.module_id, q6_param.param_id,
q6_param.payload_size);
rc = -EINVAL;
break;
}
payload = kzalloc(q6_param.payload_size, GFP_KERNEL);
if (!payload) {
pr_aud_err("%s: failed to allocate memory\n",
__func__);
rc = -ENOMEM;
break;
}
if (copy_from_user(payload, (void *) (arg + sizeof(q6_param)),
q6_param.payload_size)) {
pr_aud_err("%s: copy payload from user failed\n",
__func__);
kfree(payload);
rc = -EFAULT;
break;;
}
if (q6_param.effect_type == 0) {
rc = q6asm_enable_effect(audio->ac,
q6_param.module_id,
q6_param.param_id,
q6_param.payload_size,
payload);
pr_aud_info("q6asm_enable_effect, return %d (session %d)\n", rc, audio->ac->session);
}
#if Q6_EFFECT_DEBUG
{
int *ptr;
int i;
ptr = (int *)payload;
for (i = 0; i < (q6_param.payload_size / 4); i++)
pr_aud_info("0x%08x", *(ptr + i));
}
#endif
kfree(payload);
pr_aud_info("AUDIO_SET_Q6_EFFECT, session %d ---\n", audio->ac->session);
break;
}
default:
rc = audio->codec_ioctl(file, cmd, arg);
if (rc)
pr_err("%s[%p]:Failed in utils_ioctl: %d\n",
__func__, audio, rc);
}
return rc;
}
