/* ------------------- device --------------------- */
static long audio_in_ioctl_shared(struct file *file,
unsigned int cmd, unsigned long arg)
{
struct q6audio_in *audio = file->private_data;
int rc = 0;
switch (cmd) {
case AUDIO_FLUSH: {
/* 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.
*/
rc = audio_in_flush(audio);
if (rc < 0)
pr_err("%s:session id %d: Flush Fail rc=%d\n",
__func__, audio->ac->session, rc);
else { /* Register back the flushed read buffer with DSP */
int cnt = 0;
while (cnt++ < audio->str_cfg.buffer_count)
q6asm_read(audio->ac); /* Push buffer to DSP */
pr_debug("register the read buffer\n");
}
break;
}
case AUDIO_PAUSE: {
pr_debug("%s:session id %d: AUDIO_PAUSE\n", __func__,
audio->ac->session);
if (audio->enabled)
audio_in_pause(audio);
break;
}
case AUDIO_GET_SESSION_ID: {
if (copy_to_user((void *) arg, &audio->ac->session,
sizeof(u16))) {
pr_err("%s: copy_to_user for AUDIO_GET_SESSION_ID failed\n",
__func__);
rc = -EFAULT;
}
break;
}
default:
pr_err("%s: Unknown ioctl cmd = %d", __func__, cmd);
rc = -EINVAL;
}
return rc;
}
ssize_t audio_in_read(struct file *file,
char __user *buf,
size_t count, loff_t *pos)
{
struct q6audio_in *audio = file->private_data;
const char __user *start = buf;
unsigned char *data;
uint32_t offset = 0;
uint32_t size = 0;
int rc = 0;
uint32_t idx;
struct meta_out_dsp meta;
uint32_t bytes_to_copy = 0;
uint32_t mfield_size = (audio->buf_cfg.meta_info_enable == 0) ? 0 :
(sizeof(unsigned char) +
(sizeof(struct meta_out_dsp)*(audio->buf_cfg.frames_per_buf)));
memset(&meta, 0, sizeof(meta));
pr_debug("%s:session id %d: read - %d\n", __func__, audio->ac->session,
count);
if (!audio->enabled)
return -EFAULT;
mutex_lock(&audio->read_lock);
while (count > 0) {
rc = wait_event_interruptible(
audio->read_wait,
((atomic_read(&audio->out_count) > 0) ||
(audio->stopped) ||
audio->rflush || audio->eos_rsp ||
audio->event_abort));
if (audio->event_abort) {
rc = -EIO;
break;
}
if (rc < 0)
break;
if ((audio->stopped && !(atomic_read(&audio->out_count))) ||
audio->rflush) {
pr_debug("%s:session id %d: driver in stop state or flush,No more buf to read",
__func__,
audio->ac->session);
rc = 0;/* End of File */
break;
}
if (!(atomic_read(&audio->out_count)) &&
(audio->eos_rsp == 1) &&
(count >= (sizeof(unsigned char) +
sizeof(struct meta_out_dsp)))) {
unsigned char num_of_frames;
pr_info("%s:session id %d: eos %d at output\n",
__func__, audio->ac->session, audio->eos_rsp);
if (buf != start)
break;
num_of_frames = 0xFF;
if (copy_to_user(buf, &num_of_frames,
sizeof(unsigned char))) {
rc = -EFAULT;
break;
}
buf += sizeof(unsigned char);
meta.frame_size = 0xFFFF;
meta.encoded_pcm_samples = 0xFFFF;
meta.msw_ts = 0x00;
meta.lsw_ts = 0x00;
meta.nflags = AUD_EOS_SET;
audio->eos_rsp = 0;
if (copy_to_user(buf, &meta, sizeof(meta))) {
rc = -EFAULT;
break;
}
buf += sizeof(meta);
break;
}
data = (unsigned char *)q6asm_is_cpu_buf_avail(OUT, audio->ac,
&size, &idx);
if ((count >= (size + mfield_size)) && data) {
if (audio->buf_cfg.meta_info_enable) {
if (copy_to_user(buf,
&audio->out_frame_info[idx][0],
sizeof(unsigned char))) {
rc = -EFAULT;
break;
}
bytes_to_copy =
(size + audio->out_frame_info[idx][1]);
/* Number of frames information copied */
buf += sizeof(unsigned char);
count -= sizeof(unsigned char);
} else {
offset = audio->out_frame_info[idx][1];
bytes_to_copy = size;
}
pr_debug("%s:session id %d: offset=%d nr of frames= %d\n",
__func__, audio->ac->session,
audio->out_frame_info[idx][1],
audio->out_frame_info[idx][0]);
if (copy_to_user(buf, &data[offset], bytes_to_copy)) {
rc = -EFAULT;
break;
}
count -= bytes_to_copy;
buf += bytes_to_copy;
} else {
pr_err("%s:session id %d: short read data[%p] bytesavail[%d]bytesrequest[%d]\n",
__func__,
audio->ac->session,
data, size, count);
}
atomic_dec(&audio->out_count);
q6asm_read(audio->ac);
break;
}
mutex_unlock(&audio->read_lock);
pr_debug("%s:session id %d: read: %d bytes\n", __func__,
audio->ac->session, (buf-start));
if (buf > start)
return buf - start;
return rc;
}
/* ------------------- device --------------------- */
long audio_in_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
struct q6audio_in *audio = file->private_data;
int rc = 0;
if (cmd == AUDIO_GET_STATS) {
struct msm_audio_stats stats;
memset(&stats, 0, sizeof(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) {
case AUDIO_FLUSH: {
/* 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.
*/
rc = audio_in_flush(audio);
if (rc < 0)
pr_err("%s:session id %d: Flush Fail rc=%d\n",
__func__, audio->ac->session, rc);
else { /* Register back the flushed read buffer with DSP */
int cnt = 0;
while (cnt++ < audio->str_cfg.buffer_count)
q6asm_read(audio->ac); /* Push buffer to DSP */
pr_debug("register the read buffer\n");
}
break;
}
case AUDIO_PAUSE: {
pr_debug("%s:session id %d: AUDIO_PAUSE\n", __func__,
audio->ac->session);
if (audio->enabled)
audio_in_pause(audio);
break;
}
case AUDIO_GET_STREAM_CONFIG: {
struct msm_audio_stream_config cfg;
memset(&cfg, 0, sizeof(cfg));
cfg.buffer_size = audio->str_cfg.buffer_size;
cfg.buffer_count = audio->str_cfg.buffer_count;
if (copy_to_user((void *)arg, &cfg, sizeof(cfg)))
rc = -EFAULT;
pr_debug("%s:session id %d: AUDIO_GET_STREAM_CONFIG %d %d\n",
__func__, audio->ac->session, cfg.buffer_size,
cfg.buffer_count);
break;
}
case AUDIO_SET_STREAM_CONFIG: {
struct msm_audio_stream_config cfg;
if (copy_from_user(&cfg, (void *)arg, sizeof(cfg))) {
rc = -EFAULT;
break;
}
/* Minimum single frame size,
but with in maximum frames number */
if ((cfg.buffer_size < (audio->min_frame_size+ \
sizeof(struct meta_out_dsp))) ||
(cfg.buffer_count < FRAME_NUM)) {
rc = -EINVAL;
break;
}
audio->str_cfg.buffer_size = cfg.buffer_size;
audio->str_cfg.buffer_count = cfg.buffer_count;
if(audio->opened){
rc = q6asm_audio_client_buf_alloc(OUT,audio->ac,
ALIGN_BUF_SIZE(audio->str_cfg.buffer_size),
audio->str_cfg.buffer_count);
if (rc < 0) {
pr_err("%s: session id %d: Buffer Alloc failed rc=%d\n",
__func__, audio->ac->session, rc);
rc = -ENOMEM;
break;
}
}
audio->buf_alloc |= BUF_ALLOC_OUT;
rc = 0;
pr_debug("%s:session id %d: AUDIO_SET_STREAM_CONFIG %d %d\n",
__func__, audio->ac->session,
audio->str_cfg.buffer_size,
audio->str_cfg.buffer_count);
break;
}
case AUDIO_GET_SESSION_ID: {
if (copy_to_user((void *) arg, &audio->ac->session,
sizeof(unsigned short))) {
rc = -EFAULT;
}
break;
}
case AUDIO_SET_BUF_CFG: {
struct msm_audio_buf_cfg cfg;
if (copy_from_user(&cfg, (void *)arg, sizeof(cfg))) {
rc = -EFAULT;
break;
}
if ((audio->feedback == NON_TUNNEL_MODE) &&
!cfg.meta_info_enable) {
rc = -EFAULT;
break;
}
/* Restrict the num of frames per buf to coincide with
* default buf size */
if (cfg.frames_per_buf > audio->max_frames_per_buf) {
rc = -EFAULT;
break;
}
audio->buf_cfg.meta_info_enable = cfg.meta_info_enable;
audio->buf_cfg.frames_per_buf = cfg.frames_per_buf;
pr_debug("%s:session id %d: Set-buf-cfg: meta[%d] framesperbuf[%d]\n",
__func__,
audio->ac->session, cfg.meta_info_enable,
cfg.frames_per_buf);
break;
}
case AUDIO_GET_BUF_CFG: {
pr_debug("%s:session id %d: Get-buf-cfg: meta[%d] framesperbuf[%d]\n",
__func__,
audio->ac->session, audio->buf_cfg.meta_info_enable,
audio->buf_cfg.frames_per_buf);
if (copy_to_user((void *)arg, &audio->buf_cfg,
sizeof(struct msm_audio_buf_cfg)))
rc = -EFAULT;
break;
}
case AUDIO_GET_CONFIG: {
if (copy_to_user((void *)arg, &audio->pcm_cfg,
sizeof(struct msm_audio_config)))
rc = -EFAULT;
break;
}
case AUDIO_SET_CONFIG: {
struct msm_audio_config cfg;
if (copy_from_user(&cfg, (void *)arg, sizeof(cfg))) {
rc = -EFAULT;
break;
}
if (audio->feedback != NON_TUNNEL_MODE) {
pr_err("%s:session id %d: Not sufficient permission to change the record mode\n",
__func__,
audio->ac->session);
rc = -EACCES;
break;
}
if ((cfg.buffer_count > PCM_BUF_COUNT) ||
(cfg.buffer_count == 1))
cfg.buffer_count = PCM_BUF_COUNT;
audio->pcm_cfg.buffer_count = cfg.buffer_count;
audio->pcm_cfg.buffer_size = cfg.buffer_size;
audio->pcm_cfg.channel_count = cfg.channel_count;
audio->pcm_cfg.sample_rate = cfg.sample_rate;
if(audio->opened && audio->feedback == NON_TUNNEL_MODE){
rc = q6asm_audio_client_buf_alloc(IN, audio->ac,
ALIGN_BUF_SIZE(audio->pcm_cfg.buffer_size),
audio->pcm_cfg.buffer_count);
if(rc < 0){
pr_err("%s:session id %d: Buffer Alloc failed\n",
__func__,audio->ac->session);
rc = -ENOMEM;
break;
}
}
audio->buf_alloc |= BUF_ALLOC_IN;
rc = 0;
pr_debug("%s:session id %d: AUDIO_SET_CONFIG %d %d\n", __func__,
audio->ac->session, audio->pcm_cfg.buffer_count,
audio->pcm_cfg.buffer_size);
break;
}
default:
/* call codec specific ioctl */
rc = audio->enc_ioctl(file, cmd, arg);
}
mutex_unlock(&audio->lock);
return rc;
}
static long aac_in_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
struct q6audio_in *audio = file->private_data;
int rc = 0;
int cnt = 0;
switch (cmd) {
case AUDIO_START: {
struct msm_audio_aac_enc_config *enc_cfg;
struct msm_audio_aac_config *aac_config;
uint32_t aac_mode = AAC_ENC_MODE_AAC_LC;
enc_cfg = audio->enc_cfg;
aac_config = audio->codec_cfg;
/* */
pr_debug("%s:session id %d: default buf alloc[%d]\n", __func__,
audio->ac->session, audio->buf_alloc);
if (audio->enabled == 1) {
pr_info("%s:AUDIO_START already over\n", __func__);
rc = 0;
break;
}
if (audio->opened) {
rc = audio_in_buf_alloc(audio);
if (rc < 0) {
pr_err("%s:session id %d: buffer allocation failed\n",
__func__, audio->ac->session);
break;
}
} else {
if(audio->feedback == NON_TUNNEL_MODE){
pr_debug("%s: starting in non_tunnel mode",__func__);
rc = q6asm_open_read_write(audio->ac, FORMAT_MPEG4_AAC,
FORMAT_LINEAR_PCM);
if (rc < 0) {
pr_err("%s:open read write failed\n", __func__);
break;
}
}
if(audio->feedback == TUNNEL_MODE){
pr_debug("%s: starting in tunnel mode",__func__);
rc = q6asm_open_read(audio->ac,FORMAT_MPEG4_AAC);
if (rc < 0) {
pr_err("%s:open read failed\n", __func__);
break;
}
}
audio->stopped = 0;
}
pr_debug("%s:sbr_ps_flag = %d, sbr_flag = %d\n", __func__,
aac_config->sbr_ps_on_flag, aac_config->sbr_on_flag);
if (aac_config->sbr_ps_on_flag)
aac_mode = AAC_ENC_MODE_EAAC_P;
else if (aac_config->sbr_on_flag)
aac_mode = AAC_ENC_MODE_AAC_P;
else
aac_mode = AAC_ENC_MODE_AAC_LC;
rc = q6asm_enc_cfg_blk_aac(audio->ac,
audio->buf_cfg.frames_per_buf,
enc_cfg->sample_rate,
enc_cfg->channels,
enc_cfg->bit_rate,
aac_mode,
enc_cfg->stream_format);
if (rc < 0) {
pr_err("%s:session id %d: cmd media format block"
"failed\n", __func__, audio->ac->session);
break;
}
if (audio->feedback == NON_TUNNEL_MODE) {
rc = q6asm_media_format_block_pcm(audio->ac,
audio->pcm_cfg.sample_rate,
audio->pcm_cfg.channel_count);
if (rc < 0) {
pr_err("%s:session id %d: media format block"
"failed\n", __func__, audio->ac->session);
break;
}
}
rc = audio_in_enable(audio);
if (!rc) {
audio->enabled = 1;
} else {
audio->enabled = 0;
pr_err("%s:session id %d: Audio Start procedure"
"failed rc=%d\n", __func__, audio->ac->session, rc);
break;
}
while (cnt++ < audio->str_cfg.buffer_count)
q6asm_read(audio->ac);
pr_debug("%s:session id %d: AUDIO_START success enable[%d]\n",
__func__, audio->ac->session, audio->enabled);
break;
}
case AUDIO_STOP: {
pr_debug("%s:session id %d: Rxed AUDIO_STOP\n", __func__,
audio->ac->session);
rc = audio_in_disable(audio);
if (rc < 0) {
pr_err("%s:session id %d: Audio Stop procedure failed"
"rc=%d\n", __func__, audio->ac->session, rc);
break;
}
break;
}
case AUDIO_GET_AAC_ENC_CONFIG: {
struct msm_audio_aac_enc_config cfg;
struct msm_audio_aac_enc_config *enc_cfg;
memset(&cfg, 0, sizeof(cfg));
enc_cfg = audio->enc_cfg;
if (enc_cfg->channels == CH_MODE_MONO)
cfg.channels = 1;
else
cfg.channels = 2;
cfg.sample_rate = enc_cfg->sample_rate;
cfg.bit_rate = enc_cfg->bit_rate;
/* */
cfg.stream_format = ((enc_cfg->stream_format == \
0x00) ? AUDIO_AAC_FORMAT_ADTS : AUDIO_AAC_FORMAT_RAW);
pr_debug("%s:session id %d: Get-aac-cfg: format=%d sr=%d"
"bitrate=%d\n", __func__, audio->ac->session,
cfg.stream_format, cfg.sample_rate, cfg.bit_rate);
if (copy_to_user((void *)arg, &cfg, sizeof(cfg)))
rc = -EFAULT;
break;
}
case AUDIO_SET_AAC_ENC_CONFIG: {
struct msm_audio_aac_enc_config cfg;
struct msm_audio_aac_enc_config *enc_cfg;
enc_cfg = audio->enc_cfg;
if (copy_from_user(&cfg, (void *)arg, sizeof(cfg))) {
rc = -EFAULT;
break;
}
pr_debug("%s:session id %d: Set-aac-cfg: stream=%d\n", __func__,
audio->ac->session, cfg.stream_format);
if ((cfg.stream_format != AUDIO_AAC_FORMAT_RAW) &&
(cfg.stream_format != AAC_FORMAT_ADTS)) {
pr_err("%s:session id %d: unsupported AAC format\n",
__func__, audio->ac->session);
rc = -EINVAL;
break;
}
if (cfg.channels == 1) {
cfg.channels = CH_MODE_MONO;
} else if (cfg.channels == 2) {
cfg.channels = CH_MODE_STEREO;
} else {
rc = -EINVAL;
break;
}
if ((cfg.sample_rate < 8000) && (cfg.sample_rate > 48000)) {
pr_err("%s: ERROR in setting samplerate = %d\n",
__func__, cfg.sample_rate);
rc = -EINVAL;
break;
}
/*
*/
if ((cfg.bit_rate < 4000) || (cfg.bit_rate > 192000)) {
pr_err("%s: ERROR in setting bitrate = %d\n",
__func__, cfg.bit_rate);
rc = -EINVAL;
break;
}
enc_cfg->sample_rate = cfg.sample_rate;
enc_cfg->channels = cfg.channels;
enc_cfg->bit_rate = cfg.bit_rate;
enc_cfg->stream_format =
((cfg.stream_format == AUDIO_AAC_FORMAT_RAW) ? \
0x03 : 0x00);
pr_debug("%s:session id %d: Set-aac-cfg:SR= 0x%x ch=0x%x"
"bitrate=0x%x, format(adts/raw) = %d\n",
__func__, audio->ac->session, enc_cfg->sample_rate,
enc_cfg->channels, enc_cfg->bit_rate,
enc_cfg->stream_format);
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_cfg;
struct msm_audio_aac_config *audio_aac_cfg;
struct msm_audio_aac_enc_config *enc_cfg;
enc_cfg = audio->enc_cfg;
audio_aac_cfg = audio->codec_cfg;
if (copy_from_user(&aac_cfg, (void *)arg,
sizeof(struct msm_audio_aac_config))) {
rc = -EFAULT;
break;
}
pr_debug("%s:session id %d: AUDIO_SET_AAC_CONFIG: sbr_flag = %d"
" sbr_ps_flag = %d\n", __func__,
audio->ac->session, aac_cfg.sbr_on_flag,
aac_cfg.sbr_ps_on_flag);
audio_aac_cfg->sbr_on_flag = aac_cfg.sbr_on_flag;
audio_aac_cfg->sbr_ps_on_flag = aac_cfg.sbr_ps_on_flag;
if ((audio_aac_cfg->sbr_on_flag == 1) ||
(audio_aac_cfg->sbr_ps_on_flag == 1)) {
if (enc_cfg->sample_rate < 24000) {
pr_err("%s: ERROR in setting samplerate = %d"
"\n", __func__, enc_cfg->sample_rate);
rc = -EINVAL;
break;
}
}
break;
}
default:
rc = -EINVAL;
}
return rc;
}
static long amrnb_in_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
struct q6audio_in *audio = file->private_data;
int rc = 0;
int cnt = 0;
switch (cmd) {
case AUDIO_START: {
struct msm_audio_amrnb_enc_config_v2 *enc_cfg;
enc_cfg = audio->enc_cfg;
pr_debug("%s:session id %d: default buf alloc[%d]\n", __func__,
audio->ac->session, audio->buf_alloc);
if (audio->enabled == 1) {
pr_info("%s:AUDIO_START already over\n", __func__);
rc = 0;
break;
}
rc = audio_in_buf_alloc(audio);
if (rc < 0) {
pr_err("%s:session id %d: buffer allocation failed\n",
__func__, audio->ac->session);
break;
}
rc = q6asm_enc_cfg_blk_amrnb(audio->ac,
audio->buf_cfg.frames_per_buf,
enc_cfg->band_mode,
enc_cfg->dtx_enable);
if (rc < 0) {
pr_err("%s:session id %d: cmd amrnb media format block"
"failed\n", __func__, audio->ac->session);
break;
}
if (audio->feedback == NON_TUNNEL_MODE) {
rc = q6asm_media_format_block_pcm(audio->ac,
audio->pcm_cfg.sample_rate,
audio->pcm_cfg.channel_count);
if (rc < 0) {
pr_err("%s:session id %d: media format block"
"failed\n", __func__, audio->ac->session);
break;
}
}
pr_debug("%s:session id %d: AUDIO_START enable[%d]\n",
__func__, audio->ac->session,
audio->enabled);
rc = audio_in_enable(audio);
if (!rc) {
audio->enabled = 1;
} else {
audio->enabled = 0;
pr_err("%s:session id %d: Audio Start procedure failed"
"rc=%d\n", __func__,
audio->ac->session, rc);
break;
}
while (cnt++ < audio->str_cfg.buffer_count)
q6asm_read(audio->ac);
rc = 0;
pr_debug("%s:session id %d: AUDIO_START success enable[%d]\n",
__func__, audio->ac->session, audio->enabled);
break;
}
case AUDIO_STOP: {
pr_debug("%s:AUDIO_STOP\n", __func__);
rc = audio_in_disable(audio);
if (rc < 0) {
pr_err("%s:session id %d: Audio Stop procedure failed"
"rc=%d\n", __func__,
audio->ac->session, rc);
break;
}
break;
}
case AUDIO_GET_AMRNB_ENC_CONFIG_V2: {
if (copy_to_user((void *)arg, audio->enc_cfg,
sizeof(struct msm_audio_amrnb_enc_config_v2)))
rc = -EFAULT;
break;
}
case AUDIO_SET_AMRNB_ENC_CONFIG_V2: {
struct msm_audio_amrnb_enc_config_v2 cfg;
struct msm_audio_amrnb_enc_config_v2 *enc_cfg;
enc_cfg = audio->enc_cfg;
if (copy_from_user(&cfg, (void *) arg,
sizeof(struct msm_audio_amrnb_enc_config_v2))) {
rc = -EFAULT;
break;
}
if (cfg.band_mode > 8 ||
cfg.band_mode < 1) {
pr_err("%s:session id %d: invalid band mode\n",
__func__, audio->ac->session);
rc = -EINVAL;
break;
}
enc_cfg->band_mode = (cfg.band_mode - 1);
enc_cfg->dtx_enable = (cfg.dtx_enable ? 1 : 0);
enc_cfg->frame_format = 0;
pr_debug("%s:session id %d: band_mode = 0x%x dtx_enable=0x%x\n",
__func__, audio->ac->session,
enc_cfg->band_mode, enc_cfg->dtx_enable);
break;
}
default:
rc = -EINVAL;
}
return rc;
}
static long aac_in_ioctl_shared(struct file *file, unsigned int cmd, void *arg)
{
struct q6audio_in *audio = file->private_data;
int rc = 0;
int cnt = 0;
switch (cmd) {
case AUDIO_START: {
struct msm_audio_aac_enc_config *enc_cfg;
struct msm_audio_aac_config *aac_config;
uint32_t aac_mode = AAC_ENC_MODE_AAC_LC;
enc_cfg = audio->enc_cfg;
aac_config = audio->codec_cfg;
/* ENCODE CFG (after new set of API's are published )bharath*/
pr_debug("%s:session id %d: default buf alloc[%d]\n", __func__,
audio->ac->session, audio->buf_alloc);
if (audio->enabled == 1) {
pr_info("%s:AUDIO_START already over\n", __func__);
rc = 0;
break;
}
if (audio->opened) {
rc = audio_in_buf_alloc(audio);
if (rc < 0) {
pr_err("%s:session id %d: buffer allocation failed\n",
__func__, audio->ac->session);
break;
}
} else {
if (audio->feedback == NON_TUNNEL_MODE) {
pr_debug("%s: starting in non_tunnel mode",
__func__);
rc = q6asm_open_read_write(audio->ac,
FORMAT_MPEG4_AAC, FORMAT_LINEAR_PCM);
if (rc < 0) {
pr_err("%s:open read write failed\n",
__func__);
break;
}
}
if (audio->feedback == TUNNEL_MODE) {
pr_debug("%s: starting in tunnel mode",
__func__);
rc = q6asm_open_read(audio->ac,
FORMAT_MPEG4_AAC);
if (rc < 0) {
pr_err("%s:open read failed\n",
__func__);
break;
}
}
audio->stopped = 0;
}
pr_debug("%s:sbr_ps_flag = %d, sbr_flag = %d\n", __func__,
aac_config->sbr_ps_on_flag, aac_config->sbr_on_flag);
if (aac_config->sbr_ps_on_flag)
aac_mode = AAC_ENC_MODE_EAAC_P;
else if (aac_config->sbr_on_flag)
aac_mode = AAC_ENC_MODE_AAC_P;
else
aac_mode = AAC_ENC_MODE_AAC_LC;
rc = q6asm_enc_cfg_blk_aac(audio->ac,
audio->buf_cfg.frames_per_buf,
enc_cfg->sample_rate,
enc_cfg->channels,
enc_cfg->bit_rate,
aac_mode,
enc_cfg->stream_format);
if (rc < 0) {
pr_err("%s:session id %d: cmd media format block"
"failed\n", __func__, audio->ac->session);
break;
}
if (audio->feedback == NON_TUNNEL_MODE) {
rc = q6asm_media_format_block_pcm(audio->ac,
audio->pcm_cfg.sample_rate,
audio->pcm_cfg.channel_count);
if (rc < 0) {
pr_err("%s:session id %d: media format block"
"failed\n", __func__, audio->ac->session);
break;
}
}
rc = audio_in_enable(audio);
if (!rc) {
audio->enabled = 1;
} else {
audio->enabled = 0;
pr_err("%s:session id %d: Audio Start procedure"
"failed rc=%d\n", __func__, audio->ac->session, rc);
break;
}
while (cnt++ < audio->str_cfg.buffer_count)
q6asm_read(audio->ac);
pr_debug("%s:session id %d: AUDIO_START success enable[%d]\n",
__func__, audio->ac->session, audio->enabled);
break;
}
case AUDIO_STOP: {
pr_debug("%s:session id %d: Rxed AUDIO_STOP\n", __func__,
audio->ac->session);
rc = audio_in_disable(audio);
if (rc < 0) {
pr_err("%s:session id %d: Audio Stop procedure failed"
"rc=%d\n", __func__, audio->ac->session, rc);
break;
}
break;
}
case AUDIO_GET_AAC_ENC_CONFIG: {
struct msm_audio_aac_enc_config *cfg;
struct msm_audio_aac_enc_config *enc_cfg;
cfg = (struct msm_audio_aac_enc_config *)arg;
if (cfg == NULL) {
pr_err("%s: NULL config pointer for %s\n",
__func__, "AUDIO_GET_AAC_CONFIG");
rc = -EINVAL;
break;
}
memset(cfg, 0, sizeof(*cfg));
enc_cfg = audio->enc_cfg;
if (enc_cfg->channels == CH_MODE_MONO)
cfg->channels = 1;
else
cfg->channels = 2;
cfg->sample_rate = enc_cfg->sample_rate;
cfg->bit_rate = enc_cfg->bit_rate;
switch (enc_cfg->stream_format) {
case 0x00:
cfg->stream_format = AUDIO_AAC_FORMAT_ADTS;
break;
case 0x01:
cfg->stream_format = AUDIO_AAC_FORMAT_LOAS;
break;
case 0x02:
cfg->stream_format = AUDIO_AAC_FORMAT_ADIF;
break;
default:
case 0x03:
cfg->stream_format = AUDIO_AAC_FORMAT_RAW;
}
pr_debug("%s:session id %d: Get-aac-cfg: format=%d sr=%d"
"bitrate=%d\n", __func__, audio->ac->session,
cfg->stream_format, cfg->sample_rate, cfg->bit_rate);
break;
}
case AUDIO_SET_AAC_ENC_CONFIG: {
struct msm_audio_aac_enc_config *cfg;
struct msm_audio_aac_enc_config *enc_cfg;
uint32_t min_bitrate, max_bitrate;
cfg = (struct msm_audio_aac_enc_config *)arg;
if (cfg == NULL) {
pr_err("%s: NULL config pointer for %s\n",
"AUDIO_SET_AAC_ENC_CONFIG", __func__);
rc = -EINVAL;
break;
}
enc_cfg = audio->enc_cfg;
pr_debug("%s:session id %d: Set-aac-cfg: stream=%d\n", __func__,
audio->ac->session, cfg->stream_format);
switch (cfg->stream_format) {
case AUDIO_AAC_FORMAT_ADTS:
enc_cfg->stream_format = 0x00;
break;
case AUDIO_AAC_FORMAT_LOAS:
enc_cfg->stream_format = 0x01;
break;
case AUDIO_AAC_FORMAT_ADIF:
enc_cfg->stream_format = 0x02;
break;
case AUDIO_AAC_FORMAT_RAW:
enc_cfg->stream_format = 0x03;
break;
default:
pr_err("%s:session id %d: unsupported AAC format %d\n",
__func__, audio->ac->session,
cfg->stream_format);
rc = -EINVAL;
break;
}
if (cfg->channels == 1) {
cfg->channels = CH_MODE_MONO;
} else if (cfg->channels == 2) {
cfg->channels = CH_MODE_STEREO;
} else {
rc = -EINVAL;
break;
}
min_bitrate = ((cfg->sample_rate)*(cfg->channels))/2;
/* This calculation should be based on AAC mode. But we cannot
* get AAC mode in this setconfig. min_bitrate's logical max
* value is 24000. So if min_bitrate is higher than 24000,
* choose 24000.
*/
if (min_bitrate > 24000)
min_bitrate = 24000;
max_bitrate = 6*(cfg->sample_rate)*(cfg->channels);
if (max_bitrate > 320000)
max_bitrate = 320000;
if ((cfg->bit_rate < min_bitrate) ||
(cfg->bit_rate > max_bitrate)) {
pr_err("%s: bitrate permissible: max=%d, min=%d\n",
__func__, max_bitrate, min_bitrate);
pr_err("%s: ERROR in setting bitrate = %d\n",
__func__, cfg->bit_rate);
rc = -EINVAL;
break;
}
enc_cfg->sample_rate = cfg->sample_rate;
enc_cfg->channels = cfg->channels;
enc_cfg->bit_rate = cfg->bit_rate;
pr_debug("%s:session id %d: Set-aac-cfg:SR= 0x%x ch=0x%x"
"bitrate=0x%x, format(adts/raw) = %d\n",
__func__, audio->ac->session, enc_cfg->sample_rate,
enc_cfg->channels, enc_cfg->bit_rate,
enc_cfg->stream_format);
break;
}
case AUDIO_SET_AAC_CONFIG: {
struct msm_audio_aac_config *aac_cfg;
struct msm_audio_aac_config *audio_aac_cfg;
struct msm_audio_aac_enc_config *enc_cfg;
enc_cfg = audio->enc_cfg;
audio_aac_cfg = audio->codec_cfg;
aac_cfg = (struct msm_audio_aac_config *)arg;
if (aac_cfg == NULL) {
pr_err("%s: NULL config pointer %s\n",
__func__, "AUDIO_SET_AAC_CONFIG");
rc = -EINVAL;
break;
}
pr_debug("%s:session id %d: AUDIO_SET_AAC_CONFIG: sbr_flag = %d sbr_ps_flag = %d\n",
__func__, audio->ac->session, aac_cfg->sbr_on_flag,
aac_cfg->sbr_ps_on_flag);
audio_aac_cfg->sbr_on_flag = aac_cfg->sbr_on_flag;
audio_aac_cfg->sbr_ps_on_flag = aac_cfg->sbr_ps_on_flag;
if ((audio_aac_cfg->sbr_on_flag == 1) ||
(audio_aac_cfg->sbr_ps_on_flag == 1)) {
if (enc_cfg->sample_rate < 24000) {
pr_err("%s: ERROR in setting samplerate = %d"
"\n", __func__, enc_cfg->sample_rate);
rc = -EINVAL;
break;
}
}
break;
}
default:
pr_err("%s: Unknown ioctl cmd = %d", __func__, cmd);
rc = -EINVAL;
}
return rc;
}
/* ------------------- device --------------------- */
static long evrc_in_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
struct q6audio_in *audio = file->private_data;
int rc = 0;
int cnt = 0;
switch (cmd) {
case AUDIO_START: {
struct msm_audio_evrc_enc_config *enc_cfg;
enc_cfg = audio->enc_cfg;
pr_debug("%s:session id %d: default buf alloc[%d]\n", __func__,
audio->ac->session, audio->buf_alloc);
if (audio->enabled == 1) {
pr_info("%s:AUDIO_START already over\n", __func__);
rc = 0;
break;
}
rc = audio_in_buf_alloc(audio);
if (rc < 0) {
pr_err("%s:session id %d: buffer allocation failed\n",
__func__, audio->ac->session);
break;
}
/* rate_modulation_cmd set to zero
currently not configurable from user space */
rc = q6asm_enc_cfg_blk_evrc(audio->ac,
audio->buf_cfg.frames_per_buf,
enc_cfg->min_bit_rate,
enc_cfg->max_bit_rate, 0);
if (rc < 0) {
pr_err("%s:session id %d: cmd evrc media format block"
"failed\n", __func__, audio->ac->session);
break;
}
if (audio->feedback == NON_TUNNEL_MODE) {
rc = q6asm_media_format_block_pcm(audio->ac,
audio->pcm_cfg.sample_rate,
audio->pcm_cfg.channel_count);
if (rc < 0) {
pr_err("%s:session id %d: media format block"
"failed\n", __func__, audio->ac->session);
break;
}
}
pr_debug("%s:session id %d: AUDIO_START enable[%d]\n",
__func__, audio->ac->session, audio->enabled);
rc = audio_in_enable(audio);
if (!rc) {
audio->enabled = 1;
} else {
audio->enabled = 0;
pr_err("%s:session id %d: Audio Start procedure failed"
"rc=%d\n", __func__, audio->ac->session, rc);
break;
}
while (cnt++ < audio->str_cfg.buffer_count)
q6asm_read(audio->ac); /* Push buffer to DSP */
rc = 0;
pr_debug("%s:session id %d: AUDIO_START success enable[%d]\n",
__func__, audio->ac->session, audio->enabled);
break;
}
case AUDIO_STOP: {
pr_debug("%s:session id %d: AUDIO_STOP\n", __func__,
audio->ac->session);
rc = audio_in_disable(audio);
if (rc < 0) {
pr_err("%s:session id %d: Audio Stop procedure failed"
"rc=%d\n", __func__, audio->ac->session, rc);
break;
}
break;
}
case AUDIO_GET_EVRC_ENC_CONFIG: {
if (copy_to_user((void *)arg, audio->enc_cfg,
sizeof(struct msm_audio_evrc_enc_config)))
rc = -EFAULT;
break;
}
case AUDIO_SET_EVRC_ENC_CONFIG: {
struct msm_audio_evrc_enc_config cfg;
struct msm_audio_evrc_enc_config *enc_cfg;
enc_cfg = audio->enc_cfg;
if (copy_from_user(&cfg, (void *) arg,
sizeof(struct msm_audio_evrc_enc_config))) {
rc = -EFAULT;
break;
}
if (cfg.min_bit_rate > 4 ||
cfg.min_bit_rate < 1 ||
(cfg.min_bit_rate == 2)) {
pr_err("%s:session id %d: invalid min bitrate\n",
__func__, audio->ac->session);
rc = -EINVAL;
break;
}
if (cfg.max_bit_rate > 4 ||
cfg.max_bit_rate < 1 ||
(cfg.max_bit_rate == 2)) {
pr_err("%s:session id %d: invalid max bitrate\n",
__func__, audio->ac->session);
rc = -EINVAL;
break;
}
enc_cfg->min_bit_rate = cfg.min_bit_rate;
enc_cfg->max_bit_rate = cfg.max_bit_rate;
pr_debug("%s:session id %d: min_bit_rate= 0x%x"
"max_bit_rate=0x%x\n", __func__,
audio->ac->session, enc_cfg->min_bit_rate,
enc_cfg->max_bit_rate);
break;
}
default:
rc = -EINVAL;
}
return rc;
}
