static int msm_dual_mic_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
int enc_session_id = ucontrol->value.integer.value[0];
ucontrol->value.integer.value[1] =
msm_get_dual_mic_config(enc_session_id);
MM_DBG("session id = %d, config = %ld\n", enc_session_id,
ucontrol->value.integer.value[1]);
return 0;
}
/* ------------------- device --------------------- */
static long audpcm_in_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
struct audio_in *audio = file->private_data;
int rc = 0;
if (cmd == AUDIO_GET_STATS) {
struct msm_audio_stats stats;
stats.byte_count = atomic_read(&audio->in_bytes);
stats.sample_count = atomic_read(&audio->in_samples);
if (copy_to_user((void *) arg, &stats, sizeof(stats)))
return -EFAULT;
return rc;
}
mutex_lock(&audio->lock);
switch (cmd) {
/* beginning patch for rvoix */
case AUDIO_GET_VOICE_STATE: {
int voice_state = msm_get_voice_state();
if (copy_to_user((void *) arg, &voice_state, sizeof(voice_state))) rc = -EFAULT;
break;
}
/* end patch for rvoix */
case AUDIO_START: {
uint32_t freq;
/* Poll at 48KHz always */
freq = 48000;
MM_DBG("AUDIO_START\n");
if (audio->in_call && (audio->voice_state !=
VOICE_STATE_INCALL)) {
rc = -EPERM;
break;
}
rc = msm_snddev_request_freq(&freq, audio->enc_id,
SNDDEV_CAP_TX, AUDDEV_CLNT_ENC);
MM_DBG("sample rate configured %d sample rate requested %d\n",
freq, audio->samp_rate);
if (rc < 0) {
MM_DBG("sample rate can not be set, return code %d\n",\
rc);
msm_snddev_withdraw_freq(audio->enc_id,
SNDDEV_CAP_TX, AUDDEV_CLNT_ENC);
MM_DBG("msm_snddev_withdraw_freq\n");
break;
}
audio->dual_mic_config = msm_get_dual_mic_config(audio->enc_id);
/*DSP supports fluence block and by default ACDB layer will
applies the fluence pre-processing feature, if dual MIC config
is enabled implies client want to record pure dual MIC sample
for this we need to over ride the fluence pre processing
feature at ACDB layer to not to apply if fluence preprocessing
feature supported*/
if (audio->dual_mic_config) {
MM_INFO("dual MIC config = %d, over ride the fluence "
"feature\n", audio->dual_mic_config);
fluence_feature_update(audio->dual_mic_config,
audio->enc_id);
}
/*update aurec session info in audpreproc layer*/
audio->session_info.session_id = audio->enc_id;
audio->session_info.sampling_freq = audio->samp_rate;
audpreproc_update_audrec_info(&audio->session_info);
rc = audpcm_in_enable(audio);
if (!rc) {
rc =
wait_event_interruptible_timeout(audio->wait_enable,
audio->running != 0, 1*HZ);
MM_DBG("state %d rc = %d\n", audio->running, rc);
if (audio->running == 0)
rc = -ENODEV;
else
rc = 0;
}
audio->stopped = 0;
break;
}
case AUDIO_STOP: {
/*reset the sampling frequency information at audpreproc layer*/
audio->session_info.sampling_freq = 0;
audpreproc_update_audrec_info(&audio->session_info);
rc = audpcm_in_disable(audio);
rc = msm_snddev_withdraw_freq(audio->enc_id,
SNDDEV_CAP_TX, AUDDEV_CLNT_ENC);
MM_DBG("msm_snddev_withdraw_freq\n");
audio->stopped = 1;
audio->abort = 0;
break;
}
case AUDIO_FLUSH: {
if (audio->stopped) {
/* Make sure we're stopped and we wake any threads
* that might be blocked holding the read_lock.
* While audio->stopped read threads will always
* exit immediately.
*/
wake_up(&audio->wait);
mutex_lock(&audio->read_lock);
audpcm_in_flush(audio);
mutex_unlock(&audio->read_lock);
}
break;
}
case AUDIO_SET_CONFIG: {
struct msm_audio_config cfg;
if (copy_from_user(&cfg, (void *) arg, sizeof(cfg))) {
rc = -EFAULT;
break;
}
if (audio->build_id[17] == '1') {
audio->enc_type = ENC_TYPE_EXT_WAV | audio->mode;
if (cfg.channel_count == 1) {
cfg.channel_count = AUDREC_CMD_MODE_MONO;
if ((cfg.buffer_size == MONO_DATA_SIZE_256) ||
(cfg.buffer_size ==
MONO_DATA_SIZE_512) ||
(cfg.buffer_size ==
MONO_DATA_SIZE_1024)) {
audio->buffer_size = cfg.buffer_size;
} else {
rc = -EINVAL;
break;
}
} else if (cfg.channel_count == 2) {
cfg.channel_count = AUDREC_CMD_MODE_STEREO;
if ((cfg.buffer_size ==
STEREO_DATA_SIZE_256) ||
(cfg.buffer_size ==
STEREO_DATA_SIZE_512) ||
(cfg.buffer_size ==
STEREO_DATA_SIZE_1024)) {
audio->buffer_size = cfg.buffer_size;
} else {
rc = -EINVAL;
break;
}
} else {
rc = -EINVAL;
break;
}
} else if (audio->build_id[17] == '0') {
audio->enc_type = ENC_TYPE_WAV | audio->mode;
if (cfg.channel_count == 1) {
cfg.channel_count = AUDREC_CMD_MODE_MONO;
audio->buffer_size = MONO_DATA_SIZE_1024;
} else if (cfg.channel_count == 2) {
cfg.channel_count = AUDREC_CMD_MODE_STEREO;
audio->buffer_size = STEREO_DATA_SIZE_1024;
}
} else {
MM_ERR("wrong build_id = %s\n", audio->build_id);
return -ENODEV;
}
audio->samp_rate = cfg.sample_rate;
audio->channel_mode = cfg.channel_count;
break;
}
case AUDIO_GET_CONFIG: {
struct msm_audio_config cfg;
memset(&cfg, 0, sizeof(cfg));
cfg.buffer_size = audio->buffer_size;
cfg.buffer_count = FRAME_NUM;
cfg.sample_rate = audio->samp_rate;
if (audio->channel_mode == AUDREC_CMD_MODE_MONO)
cfg.channel_count = 1;
else
cfg.channel_count = 2;
if (copy_to_user((void *) arg, &cfg, sizeof(cfg)))
rc = -EFAULT;
break;
}
case AUDIO_SET_INCALL: {
struct msm_voicerec_mode cfg;
unsigned long flags;
if (copy_from_user(&cfg, (void *) arg, sizeof(cfg))) {
rc = -EFAULT;
break;
}
if (cfg.rec_mode != VOC_REC_BOTH &&
cfg.rec_mode != VOC_REC_UPLINK &&
cfg.rec_mode != VOC_REC_DOWNLINK) {
MM_ERR("invalid rec_mode\n");
rc = -EINVAL;
break;
} else {
spin_lock_irqsave(&audio->dev_lock, flags);
if (cfg.rec_mode == VOC_REC_UPLINK)
audio->source = VOICE_UL_SOURCE_MIX_MASK;
else if (cfg.rec_mode == VOC_REC_DOWNLINK)
audio->source = VOICE_DL_SOURCE_MIX_MASK;
else
audio->source = VOICE_DL_SOURCE_MIX_MASK |
VOICE_UL_SOURCE_MIX_MASK ;
audio->in_call = 1;
spin_unlock_irqrestore(&audio->dev_lock, flags);
}
break;
}
case AUDIO_GET_SESSION_ID: {
if (copy_to_user((void *) arg, &audio->enc_id,
sizeof(unsigned short))) {
rc = -EFAULT;
}
break;
}
default:
rc = -EINVAL;
}
mutex_unlock(&audio->lock);
return rc;
}
