static int msm8k_dtmf_ioctl(struct inode *inode, struct file *f,
unsigned int cmd, unsigned long arg)
{
int rc = CAD_RES_SUCCESS;
struct dtmf *p = f->private_data;
void *cad_arg = (void *)arg;
struct cad_stream_device_struct_type cad_stream_dev;
struct cad_stream_info_struct_type cad_stream_info;
D("%s\n", __func__);
memset(&cad_stream_dev, 0,
sizeof(struct cad_stream_device_struct_type));
memset(&cad_stream_info, 0, sizeof(struct cad_stream_info_struct_type));
switch (cmd) {
case AUDIO_PLAY_DTMF:
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_GEN_DTMF,
cad_arg, sizeof(cad_arg));
if (rc) {
pr_err("cad_ioctl() CMD_GEN_DTMF failed\n");
break;
}
break;
case AUDIO_START:
cad_stream_dev.device = cad_arg;
cad_stream_dev.device_len = 1;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_DEVICE,
&cad_stream_dev, sizeof(cad_stream_dev));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_DEVICE failed\n");
break;
}
cad_stream_info.app_type = CAD_STREAM_APP_DTMF;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_INFO,
&cad_stream_info, sizeof(cad_stream_info));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_INFO failed\n");
break;
}
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_START,
NULL, 0);
if (rc) {
pr_err("cad_ioctl() CMD_STREAM_START failed\n");
break;
}
break;
default:
rc = -EINVAL;
}
return rc;
}
static int qsd_pcm_playback_close(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct qsd_audio *prtd = runtime->private_data;
int ret = 0;
if (prtd->enabled) {
mutex_lock(&the_locks.lock);
cad_ioctl(prtd->cad_w_handle,
CAD_IOCTL_CMD_STREAM_END_OF_STREAM,
NULL, 0);
mutex_unlock(&the_locks.lock);
ret = wait_event_interruptible(the_locks.eos_wait,
prtd->eos_ack);
if (!prtd->eos_ack)
pr_err("EOS Failed\n");
}
prtd->eos_ack = 0;
mutex_lock(&the_locks.lock);
cad_close(prtd->cad_w_handle);
mutex_unlock(&the_locks.lock);
prtd->enabled = 0;
/*
* TODO: Deregister the async callback handler.
* Currently cad provides no interface to do so.
*/
kfree(prtd);
return ret;
}
void msm8k_audio_dev_work(struct work_struct *work)
{
int rc;
struct cad_open_struct_type cos;
struct msm8k_audio_dev_ctrl *ctrl = &g_ctrl;
D("%s() running\n", __func__);
cos.format = 0;
cos.op_code = CAD_OPEN_OP_DEVICE_CTRL;
ctrl->cad_ctrl_handle = cad_open(&cos);
ctrl->current_rx_device = CAD_HW_DEVICE_ID_HANDSET_SPKR;
ctrl->current_tx_device = CAD_HW_DEVICE_ID_HANDSET_MIC;
if (ctrl->cad_ctrl_handle < 0)
pr_err("Dev CTRL handle < 0\n");
set_audio_ctrl_handle(ctrl->cad_ctrl_handle);
rc = cad_ioctl(ctrl->cad_ctrl_handle,
CAD_IOCTL_CMD_STREAM_START,
NULL,
0);
if (rc)
pr_err("%s: cad_ioctl() STREAM_START failed\n", __func__);
ctrl->q6_initialized = 1;
complete(&ctrl->q6_init_compl);
D("%s() done\n", __func__);
}
int qsd_audio_volume_update(struct qsd_audio *prtd)
{
int rc = 0;
struct cad_flt_cfg_strm_vol cad_strm_volume;
struct cad_filter_struct flt;
printk(KERN_INFO "qsd_audio_volume_update: updating volume");
memset(&cad_strm_volume, 0, sizeof(struct cad_flt_cfg_strm_vol));
memset(&flt, 0, sizeof(struct cad_filter_struct));
cad_strm_volume.volume = qsd_glb_ctl.strm_volume;
flt.filter_type = CAD_DEVICE_FILTER_TYPE_VOL;
flt.format_block = &cad_strm_volume;
flt.cmd = CAD_FILTER_CONFIG_STREAM_VOLUME;
flt.format_block_len = sizeof(struct cad_flt_cfg_strm_vol);
rc = cad_ioctl(prtd->cad_w_handle,
CAD_IOCTL_CMD_SET_STREAM_FILTER_CONFIG,
&flt,
sizeof(struct cad_filter_struct));
if (rc)
printk(KERN_ERR "cad_ioctl() set volume failed\n");
return rc;
}
int audio_switch_device(int new_device)
{
int rc;
struct msm8k_audio_dev_ctrl *ctrl = &g_ctrl;
struct cad_device_struct_type cad_dev;
//D("%s\n", __func__);
D("%s() new_device=0x%02x\n", __func__ , new_device );
memset(&cad_dev, 0, sizeof(struct cad_device_struct_type));
if(get_cad_hw_device_id(new_device,&cad_dev)!=CAD_RES_SUCCESS){
return -ENODEV;
}
rc = cad_ioctl(ctrl->cad_ctrl_handle,
CAD_IOCTL_CMD_DEVICE_SET_GLOBAL_DEFAULT,
&cad_dev,
sizeof(struct cad_device_struct_type));
if (rc) {
pr_err("cad_ioctl() SET_GLOBAL_DEFAULT failed\n");
return rc;
}
if (cad_dev.reserved == CAD_RX_DEVICE)
ctrl->current_rx_device = cad_dev.device;
else
ctrl->current_tx_device = cad_dev.device;
rc = cad_apply_cached_vol_on_dev(cad_dev.device);
return rc;
}
int audio_set_device_mute(struct msm_mute_info *m)
{
int rc;
struct cad_filter_struct flt;
struct cad_flt_cfg_dev_mute dev_mute_buf;
struct msm8k_audio_dev_ctrl *ctrl = &g_ctrl;
D("%s\n", __func__);
if ((m->path != CAD_RX_DEVICE) && (m->path != CAD_TX_DEVICE)) {
pr_err("%s: invalid path\n", __func__);
return -1;
}
memset(&flt, 0, sizeof(struct cad_filter_struct));
memset(&dev_mute_buf, 0,
sizeof(struct cad_flt_cfg_dev_mute));
dev_mute_buf.ver_id = CAD_FILTER_CONFIG_DEVICE_VOLUME_VERID;
if (m->path == CAD_RX_DEVICE)
dev_mute_buf.device_id = ctrl->current_rx_device;
else
dev_mute_buf.device_id = ctrl->current_tx_device;
dev_mute_buf.path = m->path;
dev_mute_buf.mute = m->mute;
flt.cmd = CAD_FILTER_CONFIG_DEVICE_MUTE;
flt.filter_type = CAD_DEVICE_FILTER_TYPE_VOL;
flt.format_block_len =
sizeof(struct cad_flt_cfg_dev_mute);
flt.format_block = &dev_mute_buf;
pr_info("msm8k_audio_dev_ctrl set device mute %d %d\n",
dev_mute_buf.path, dev_mute_buf.mute);
rc = cad_ioctl(ctrl->cad_ctrl_handle,
CAD_IOCTL_CMD_SET_DEVICE_FILTER_CONFIG,
&flt,
sizeof(struct cad_filter_struct));
if (rc)
pr_err("cad_ioctl() set mute failed\n");
else if (m->path == CAD_TX_DEVICE) {
/* Keep latest TX mute status */
atomic_set(&tx_mute, m->mute);
}
return rc;
}
int audio_set_device_volume_path(struct msm_vol_info *v)
{
int rc;
struct cad_flt_cfg_dev_vol cad_dev_volume;
struct cad_filter_struct flt;
struct msm8k_audio_dev_ctrl *ctrl = &g_ctrl;
D("%s\n", __func__);
if ((v->vol < 0) || (v->vol > 100)) {
D("invalid volume value\n");
return -EINVAL;
}
if ((v->path != CAD_RX_DEVICE) && (v->path != CAD_TX_DEVICE)) {
pr_err("%s: invalid path\n", __func__);
return -1;
}
memset(&flt, 0, sizeof(struct cad_filter_struct));
memset(&cad_dev_volume, 0,
sizeof(struct cad_flt_cfg_dev_vol));
ctrl->current_volume = v->vol;
cad_dev_volume.volume = ctrl->current_volume;
cad_dev_volume.path = v->path;
if (v->path == CAD_RX_DEVICE)
cad_dev_volume.device_id = ctrl->current_rx_device;
else
cad_dev_volume.device_id = ctrl->current_tx_device;
flt.filter_type = CAD_DEVICE_FILTER_TYPE_VOL;
flt.cmd = CAD_FILTER_CONFIG_DEVICE_VOLUME;
flt.format_block = &cad_dev_volume;
flt.format_block_len = sizeof(struct cad_flt_cfg_dev_vol);
pr_info("msm8k_audio_dev_ctrl set volume %d\n", ctrl->current_volume);
rc = cad_ioctl(ctrl->cad_ctrl_handle,
CAD_IOCTL_CMD_SET_DEVICE_FILTER_CONFIG,
&flt,
sizeof(struct cad_filter_struct));
if (rc)
pr_err("cad_ioctl() set volume failed\n");
return rc;
}
static int __init msm8k_audio_dev_ctrl_init(void)
{
struct cad_open_struct_type cos;
int rc;
struct msm8k_audio_dev_ctrl *ctrl = &g_ctrl;
D("%s\n", __func__);
rc = misc_register(&msm8k_audio_dev_ctrl_misc);
if (rc) {
pr_err("failed to register audio control device\n");
return CAD_RES_FAILURE;
}
cos.format = 0;
cos.op_code = CAD_OPEN_OP_DEVICE_CTRL;
ctrl->cad_ctrl_handle = cad_open(&cos);
ctrl->current_rx_device = CAD_HW_DEVICE_ID_HANDSET_SPKR;
ctrl->current_tx_device = CAD_HW_DEVICE_ID_HANDSET_MIC;
if (ctrl->cad_ctrl_handle < 0) {
pr_err("Dev CTRL handle < 0\n");
return CAD_RES_FAILURE;
}
set_audio_ctrl_handle(ctrl->cad_ctrl_handle);
rc = cad_ioctl(ctrl->cad_ctrl_handle,
CAD_IOCTL_CMD_STREAM_START,
NULL,
0);
if (rc) {
pr_err("%s: cad_ioctl() STREAM_START failed\n", __func__);
return CAD_RES_FAILURE;
}
#ifdef CONFIG_PROC_FS
create_proc_read_entry(MSM8K_AUDIO_PROC_NAME,
0, NULL, msm8k_audio_dev_ctrl_read_proc, NULL);
#endif
return rc;
}
static int msm8k_aac_fsync(struct file *f, struct dentry *dentry, int datasync)
{
int ret = CAD_RES_SUCCESS;
struct aac *aac = f->private_data;
mutex_lock(&aac->write_lock);
ret = cad_ioctl(aac->cad_w_handle,
CAD_IOCTL_CMD_STREAM_END_OF_STREAM, NULL, 0);
mutex_unlock(&aac->write_lock);
ret = wait_event_interruptible(aac->eos_wait, aac->eos_ack
|| aac->flush_rcvd);
aac->eos_ack = 0;
aac->flush_rcvd = 0;
return ret;
}
int audio_set_device_mute_ex(struct msm_mute_ex_info *m)
{
int rc;
struct cad_filter_struct flt;
struct cad_flt_cfg_dev_mute dev_mute_buf;
struct msm8k_audio_dev_ctrl *ctrl = &g_ctrl;
struct cad_device_struct_type cad_dev;
D("%s()\n", __func__);
memset(&flt, 0, sizeof(struct cad_filter_struct));
memset(&dev_mute_buf, 0,
sizeof(struct cad_flt_cfg_dev_mute));
memset(&cad_dev, 0, sizeof(struct cad_device_struct_type));
if(get_cad_hw_device_id(m->device,&cad_dev) != CAD_RES_SUCCESS){
pr_err("%s: invalid device\n", __func__);
return -1;
}
dev_mute_buf.ver_id = CAD_FILTER_CONFIG_DEVICE_VOLUME_VERID;
dev_mute_buf.device_id = cad_dev.device;
dev_mute_buf.path = cad_dev.reserved;
dev_mute_buf.mute = m->mute;
flt.cmd = CAD_FILTER_CONFIG_DEVICE_MUTE;
flt.filter_type = CAD_DEVICE_FILTER_TYPE_VOL;
flt.format_block_len =
sizeof(struct cad_flt_cfg_dev_mute);
flt.format_block = &dev_mute_buf;
rc = cad_ioctl(ctrl->cad_ctrl_handle,
CAD_IOCTL_CMD_SET_DEVICE_FILTER_CONFIG,
&flt,
sizeof(struct cad_filter_struct));
if (rc)
pr_err("cad_ioctl() set mute ex failed\n");
return rc;
}
static int msm8k_amr_ioctl(struct inode *inode, struct file *f,
unsigned int cmd, unsigned long arg)
{
int rc = CAD_RES_SUCCESS;
struct amr *p = f->private_data;
void *cad_arg = (void *)arg;
u32 stream_device[1];
struct cad_device_struct_type cad_dev;
struct cad_stream_device_struct_type cad_stream_dev;
struct cad_stream_info_struct_type cad_stream_info;
struct cad_amr_format cad_amr_fmt;
struct cad_flt_cfg_strm_vol cad_strm_volume;
struct cad_filter_struct flt;
u32 percentage;
D("%s\n", __func__);
memset(&cad_dev, 0, sizeof(struct cad_device_struct_type));
memset(&cad_stream_dev, 0,
sizeof(struct cad_stream_device_struct_type));
memset(&cad_stream_info, 0, sizeof(struct cad_stream_info_struct_type));
memset(&cad_amr_fmt, 0,
sizeof(struct cad_amr_format));
memset(&flt, 0, sizeof(struct cad_filter_struct));
switch (cmd) {
case AUDIO_START:
cad_stream_info.app_type = CAD_STREAM_APP_PLAYBACK;
cad_stream_info.priority = 0;
cad_stream_info.buf_mem_type = CAD_STREAM_BUF_MEM_HEAP;
cad_stream_info.ses_buf_max_size = 1024 * 11;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_INFO,
&cad_stream_info,
sizeof(struct cad_stream_info_struct_type));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_INFO failed\n");
break;
}
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_CONFIG,
&cad_amr_fmt,
sizeof(struct cad_amr_format));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_CONFIG failed\n");
break;
}
stream_device[0] = CAD_HW_DEVICE_ID_DEFAULT_RX;
cad_stream_dev.device = (u32 *)&stream_device[0];
cad_stream_dev.device_len = 1;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_DEVICE,
&cad_stream_dev,
sizeof(struct cad_stream_device_struct_type));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_DEVICE failed\n");
break;
}
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_START,
NULL, 0);
if (rc) {
pr_err("cad_ioctl() STREAM_START failed\n");
break;
}
break;
case AUDIO_STOP:
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_PAUSE,
cad_arg, sizeof(u32));
break;
case AUDIO_FLUSH:
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_FLUSH,
cad_arg, sizeof(u32));
break;
case AUDIO_GET_CONFIG:
if (copy_to_user((void *)arg, &p->cfg,
sizeof(struct msm_audio_config)))
return -EFAULT;
break;
case AUDIO_SET_CONFIG:
rc = copy_from_user(&p->cfg, (void *)arg,
sizeof(struct msm_audio_config));
break;
case AUDIO_SET_VOLUME:
rc = copy_from_user(&percentage, (void *)arg, sizeof(u32));
p->volume = qdsp6_stream_volume_mapping(percentage);
memset(&cad_strm_volume, 0,
sizeof(struct cad_flt_cfg_strm_vol));
cad_strm_volume.volume = p->volume;
flt.filter_type = CAD_DEVICE_FILTER_TYPE_VOL;
flt.format_block = &cad_strm_volume;
flt.cmd = CAD_FILTER_CONFIG_STREAM_VOLUME;
flt.format_block_len =
sizeof(struct cad_flt_cfg_strm_vol);
rc = cad_ioctl(p->cad_w_handle,
CAD_IOCTL_CMD_SET_STREAM_FILTER_CONFIG,
&flt,
sizeof(struct cad_stream_filter_struct_type));
if (rc) {
pr_err("cad_ioctl() set volume failed\n");
break;
}
break;
default:
rc = -EINVAL;
}
return rc;
}
static int qsd_pcm_open(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct qsd_audio *prtd;
struct cad_event_struct_type alsa_event;
int ret = 0;
prtd = kzalloc(sizeof(struct qsd_audio), GFP_KERNEL);
if (prtd == NULL) {
ret = -ENOMEM;
return ret;
}
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
printk(KERN_INFO "Stream = SNDRV_PCM_STREAM_PLAYBACK\n");
runtime->hw = qsd_pcm_playback_hardware;
prtd->dir = SNDRV_PCM_STREAM_PLAYBACK;
prtd->playback_substream = substream;
prtd->cos.op_code = CAD_OPEN_OP_WRITE;
} else {
printk(KERN_INFO "Stream = SNDRV_PCM_STREAM_CAPTURE\n");
runtime->hw = qsd_pcm_capture_hardware;
prtd->dir = SNDRV_PCM_STREAM_CAPTURE;
prtd->capture_substream = substream;
prtd->cos.op_code = CAD_OPEN_OP_READ;
}
/* Ensure that buffer size is a multiple of period size */
ret = snd_pcm_hw_constraint_integer(runtime,
SNDRV_PCM_HW_PARAM_PERIODS);
if (ret < 0) {
kfree(prtd);
return ret;
}
runtime->private_data = prtd;
prtd->cos.format = CAD_FORMAT_PCM;
mutex_lock(&the_locks.lock);
prtd->cad_w_handle = cad_open(&prtd->cos);
mutex_unlock(&the_locks.lock);
mutex_lock(&the_locks.lock);
if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
alsa_event.callback = &alsa_event_cb_capture;
else
alsa_event.callback = &alsa_event_cb_playback;
alsa_event.client_data = prtd;
ret = cad_ioctl(prtd->cad_w_handle,
CAD_IOCTL_CMD_SET_STREAM_EVENT_LSTR,
&alsa_event, sizeof(struct cad_event_struct_type));
if (ret) {
mutex_unlock(&the_locks.lock);
cad_close(prtd->cad_w_handle);
kfree(prtd);
return ret;
}
mutex_unlock(&the_locks.lock);
prtd->enabled = 0;
return 0;
}
static int msm8k_aac_in_ioctl(struct inode *inode, struct file *f,
unsigned int cmd, unsigned long arg)
{
int rc = CAD_RES_SUCCESS;
struct aac *p = f->private_data;
u32 stream_device[1];
struct cad_device_struct_type cad_dev;
struct cad_stream_device_struct_type cad_stream_dev;
struct cad_stream_info_struct_type cad_stream_info;
struct cad_write_aac_format_struct_type cad_write_aac_fmt;
D("%s\n", __func__);
memset(&cad_dev, 0, sizeof(struct cad_device_struct_type));
memset(&cad_stream_dev, 0,
sizeof(struct cad_stream_device_struct_type));
memset(&cad_stream_info, 0, sizeof(struct cad_stream_info_struct_type));
memset(&cad_write_aac_fmt, 0,
sizeof(struct cad_write_aac_format_struct_type));
switch (cmd) {
case AUDIO_START:
cad_stream_info.app_type = CAD_STREAM_APP_RECORD;
cad_stream_info.priority = 0;
cad_stream_info.buf_mem_type = CAD_STREAM_BUF_MEM_HEAP;
cad_stream_info.ses_buf_max_size = p->str_cfg.buffer_size;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_INFO,
&cad_stream_info,
sizeof(struct cad_stream_info_struct_type));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_INFO failed\n");
break;
}
cad_write_aac_fmt.ver_id = CAD_WRITE_AAC_VERSION_10;
cad_write_aac_fmt.aac.sample_rate = CAD_SAMPLE_RATE_48000;
cad_write_aac_fmt.aac.channel_config = p->aac_cfg.channels;
cad_write_aac_fmt.aac.block_formats = p->aac_cfg.stream_format;
cad_write_aac_fmt.aac.audio_object_type = 2;
cad_write_aac_fmt.aac.bit_rate = p->aac_cfg.bit_rate;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_CONFIG,
&cad_write_aac_fmt,
sizeof(struct cad_write_aac_format_struct_type));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_CONFIG failed\n");
break;
}
stream_device[0] = CAD_HW_DEVICE_ID_DEFAULT_TX;
cad_stream_dev.device = (u32 *)&stream_device[0];
cad_stream_dev.device_len = 1;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_DEVICE,
&cad_stream_dev,
sizeof(struct cad_stream_device_struct_type));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_DEVICE failed\n");
break;
}
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_START,
NULL, 0);
if (rc) {
pr_err("cad_ioctl() STREAM_START failed\n");
break;
}
break;
case AUDIO_STOP:
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_PAUSE,
NULL, 0);
break;
case AUDIO_FLUSH:
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_FLUSH,
NULL, 0);
break;
case AUDIO_GET_STREAM_CONFIG:
if (copy_to_user((void *)arg, &p->str_cfg,
sizeof(struct msm_audio_stream_config)))
return -EFAULT;
break;
case AUDIO_SET_STREAM_CONFIG:
if (copy_from_user(&p->str_cfg, (void *)arg,
sizeof(struct msm_audio_stream_config)))
return -EFAULT;
break;
case AUDIO_GET_AAC_ENC_CONFIG:
if (copy_to_user((void *)arg, &p->aac_cfg,
sizeof(struct msm_audio_aac_enc_config)))
return -EFAULT;
break;
case AUDIO_SET_AAC_ENC_CONFIG:
if (copy_from_user(&p->aac_cfg, (void *)arg,
sizeof(struct msm_audio_aac_enc_config)))
return -EFAULT;
if (p->aac_cfg.channels != 1) {
pr_err("only mono is supported\n");
return -EINVAL;
}
if (p->aac_cfg.sample_rate != 48000) {
pr_err("only 48KHz is supported\n");
return -EINVAL;
}
if (p->aac_cfg.stream_format != AUDIO_AAC_FORMAT_RAW &&
p->aac_cfg.stream_format != AUDIO_AAC_FORMAT_ADTS) {
pr_err("unsupported AAC format\n");
return -EINVAL;
}
break;
default:
rc = -EINVAL;
}
return rc;
}
static int msm8k_qcelp_in_ioctl(struct inode *inode, struct file *f,
unsigned int cmd, unsigned long arg)
{
int rc = 0;
struct qcelp *p = f->private_data;
u32 stream_device[1];
struct cad_device_struct_type cad_dev;
struct cad_stream_device_struct_type cad_stream_dev;
struct cad_stream_info_struct_type cad_stream_info;
struct cad_qcelp13k_format cad_qcelp_fmt;
D("%s\n", __func__);
memset(&cad_dev, 0, sizeof(struct cad_device_struct_type));
memset(&cad_stream_dev, 0,
sizeof(struct cad_stream_device_struct_type));
memset(&cad_stream_info, 0, sizeof(struct cad_stream_info_struct_type));
memset(&cad_qcelp_fmt, 0,
sizeof(struct cad_qcelp13k_format));
switch (cmd) {
case AUDIO_START:
if (p->voicerec_mode.rec_mode == VOC_REC_BOTH)
cad_stream_info.app_type = CAD_STREAM_APP_MIXED_RECORD;
else
cad_stream_info.app_type = CAD_STREAM_APP_RECORD;
cad_stream_info.priority = 0;
cad_stream_info.buf_mem_type = CAD_STREAM_BUF_MEM_HEAP;
cad_stream_info.ses_buf_max_size = QCELP_MAX_BUFFER_SIZE;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_INFO,
&cad_stream_info,
sizeof(struct cad_stream_info_struct_type));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_INFO failed\n");
break;
}
stream_device[0] = CAD_HW_DEVICE_ID_DEFAULT_TX;
cad_stream_dev.device = (u32 *)&stream_device[0];
cad_stream_dev.device_len = 1;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_DEVICE,
&cad_stream_dev,
sizeof(struct cad_stream_device_struct_type));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_DEVICE failed\n");
break;
}
cad_qcelp_fmt.size = sizeof(struct cad_qcelp13k_format);
cad_qcelp_fmt.version = 1;
cad_qcelp_fmt.channels = p->cfg.channels;
cad_qcelp_fmt.cdma_rate = p->cfg.cdma_rate;
cad_qcelp_fmt.min_bit_rate = p->cfg.min_bit_rate;
cad_qcelp_fmt.max_bit_rate = p->cfg.max_bit_rate;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_CONFIG,
&cad_qcelp_fmt,
sizeof(struct cad_qcelp13k_format));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_CONFIG failed\n");
break;
}
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_START,
NULL, 0);
if (rc) {
pr_err("cad_ioctl() STREAM_START failed\n");
break;
}
break;
case AUDIO_STOP:
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_PAUSE,
NULL, 0);
break;
case AUDIO_FLUSH:
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_FLUSH,
NULL, 0);
break;
case AUDIO_GET_CONFIG:
if (copy_to_user((void *)arg, &p->cfg,
sizeof(struct msm_audio_qcelp_config)))
return -EFAULT;
break;
case AUDIO_SET_CONFIG:
if (copy_from_user(&p->cfg, (void *)arg,
sizeof(struct msm_audio_qcelp_config)))
return -EFAULT;
if (p->cfg.min_bit_rate > 4 || p->cfg.min_bit_rate < 1) {
pr_err("invalid min bitrate\n");
return -EINVAL;
}
if (p->cfg.max_bit_rate > 4 || p->cfg.max_bit_rate < 1) {
pr_err("invalid max bitrate\n");
return -EINVAL;
}
if (p->cfg.cdma_rate > CDMA_RATE_ERASURE ||
p->cfg.cdma_rate < CDMA_RATE_BLANK) {
pr_err("invalid qcelp cdma rate\n");
return -EINVAL;
}
break;
case AUDIO_SET_INCALL:
if (copy_from_user(&p->voicerec_mode, (void *)arg,
sizeof(struct msm_voicerec_mode)))
return -EFAULT;
if (p->voicerec_mode.rec_mode != VOC_REC_BOTH &&
p->voicerec_mode.rec_mode != VOC_REC_UPLINK &&
p->voicerec_mode.rec_mode != VOC_REC_DOWNLINK) {
p->voicerec_mode.rec_mode = VOC_REC_UPLINK;
pr_err("invalid rec_mode\n");
return -EINVAL;
}
break;
default:
rc = -EINVAL;
}
return rc;
}
static int msm8k_aac_ioctl(struct inode *inode, struct file *f,
unsigned int cmd, unsigned long arg)
{
int rc;
struct aac *p = f->private_data;
u32 stream_device[1];
struct cad_device_struct_type cad_dev;
struct cad_stream_device_struct_type cad_stream_dev;
struct cad_stream_info_struct_type cad_stream_info;
struct cad_write_aac_format_struct_type cad_write_aac_fmt;
struct cad_flt_cfg_strm_vol cad_strm_volume;
struct cad_filter_struct flt;
struct cad_filter_struct cfs;
struct msm_audio_aac_config ncfg;
struct cad_event_struct_type eos_event;
D("%s\n", __func__);
memset(&cad_dev, 0, sizeof(struct cad_device_struct_type));
memset(&cad_stream_dev, 0,
sizeof(struct cad_stream_device_struct_type));
memset(&cad_stream_info, 0, sizeof(struct cad_stream_info_struct_type));
memset(&cad_write_aac_fmt, 0,
sizeof(struct cad_write_aac_format_struct_type));
memset(&flt, 0, sizeof(struct cad_filter_struct));
switch (cmd) {
case AUDIO_START:
cad_stream_info.app_type = CAD_STREAM_APP_PLAYBACK;
cad_stream_info.priority = 0;
cad_stream_info.buf_mem_type = CAD_STREAM_BUF_MEM_HEAP;
cad_stream_info.ses_buf_max_size = 1024 * 10;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_INFO,
&cad_stream_info,
sizeof(struct cad_stream_info_struct_type));
if (rc) {
D("cad_ioctl() SET_STREAM_INFO failed\n");
break;
}
stream_device[0] = CAD_HW_DEVICE_ID_DEFAULT_RX;
cad_stream_dev.device = (u32 *)&stream_device[0];
cad_stream_dev.device_len = 1;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_DEVICE,
&cad_stream_dev,
sizeof(struct cad_stream_device_struct_type));
if (rc) {
D("cad_ioctl() SET_STREAM_DEVICE failed\n");
break;
}
cad_write_aac_fmt.ver_id = CAD_WRITE_AAC_VERSION_10;
switch (p->cfg.sample_rate) {
case 96:
case 96000:
cad_write_aac_fmt.aac.sample_rate
= CAD_SAMPLE_RATE_96000;
break;
case 88:
case 88200:
cad_write_aac_fmt.aac.sample_rate
= CAD_SAMPLE_RATE_88200;
break;
case 64:
case 64000:
cad_write_aac_fmt.aac.sample_rate
= CAD_SAMPLE_RATE_64000;
break;
case 48:
case 48000:
cad_write_aac_fmt.aac.sample_rate
= CAD_SAMPLE_RATE_48000;
break;
case 44:
case 44100:
cad_write_aac_fmt.aac.sample_rate
= CAD_SAMPLE_RATE_44100;
break;
case 32:
case 32000:
cad_write_aac_fmt.aac.sample_rate
= CAD_SAMPLE_RATE_32000;
break;
case 24:
case 24000:
cad_write_aac_fmt.aac.sample_rate
= CAD_SAMPLE_RATE_24000;
break;
case 22:
case 22050:
cad_write_aac_fmt.aac.sample_rate
= CAD_SAMPLE_RATE_22050;
break;
case 16:
case 16000:
cad_write_aac_fmt.aac.sample_rate
= CAD_SAMPLE_RATE_16000;
break;
case 12:
case 12000:
cad_write_aac_fmt.aac.sample_rate
= CAD_SAMPLE_RATE_12000;
break;
case 11:
case 11025:
cad_write_aac_fmt.aac.sample_rate
= CAD_SAMPLE_RATE_11025;
break;
case 8:
case 8000:
cad_write_aac_fmt.aac.sample_rate
= CAD_SAMPLE_RATE_08000;
break;
default:
return -EINVAL;
}
cad_write_aac_fmt.aac.channel_config =
p->aac_cfg.channel_configuration;
cad_write_aac_fmt.aac.block_formats = p->aac_cfg.format;
cad_write_aac_fmt.aac.audio_object_type
= p->aac_cfg.audio_object;
cad_write_aac_fmt.aac.ep_config =
p->aac_cfg.ep_config;
cad_write_aac_fmt.aac.aac_section_data_resilience_flag =
p->aac_cfg.aac_section_data_resilience_flag;
cad_write_aac_fmt.aac.aac_scalefactor_data_resilience_flag =
p->aac_cfg.aac_scalefactor_data_resilience_flag;
cad_write_aac_fmt.aac.aac_spectral_data_resilience_flag =
p->aac_cfg.aac_spectral_data_resilience_flag;
#ifndef CONFIG_AUDIO_AAC_PLUS
cad_write_aac_fmt.aac.sbr_on_flag = AUDIO_AAC_SBR_ON_FLAG_OFF;
#else
cad_write_aac_fmt.aac.sbr_on_flag = p->aac_cfg.sbr_on_flag;
#endif
#ifndef CONFIG_AUDIO_ENHANCED_AAC_PLUS
cad_write_aac_fmt.aac.sbr_ps_on_flag =
AUDIO_AAC_SBR_PS_ON_FLAG_OFF;
#else
cad_write_aac_fmt.aac.sbr_ps_on_flag =
p->aac_cfg.sbr_ps_on_flag;
#endif
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_CONFIG,
&cad_write_aac_fmt,
sizeof(struct cad_write_aac_format_struct_type));
if (rc) {
D("cad_ioctl() SET_STREAM_CONFIG failed\n");
break;
}
eos_event.callback = &msm8k_aac_eos_event_cb;
eos_event.client_data = p;
rc = cad_ioctl(p->cad_w_handle,
CAD_IOCTL_CMD_SET_STREAM_EVENT_LSTR,
&eos_event, sizeof(struct cad_event_struct_type));
if (rc) {
D("cad_ioctl() SET_STREAM_EVENT_LSTR failed\n");
break;
}
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_START,
NULL, 0);
if (rc) {
D("cad_ioctl() STREAM_START failed\n");
break;
}
break;
case AUDIO_STOP:
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_PAUSE,
NULL, 0);
break;
case AUDIO_FLUSH:
p->flush_rcvd = 1;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_FLUSH,
NULL, 0);
wake_up(&p->eos_wait);
p->flush_rcvd = 0;
break;
case AUDIO_GET_PCM_CONFIG:
D("AUDIO_GET_PCM_CONFIG\n");
rc = CAD_RES_SUCCESS;
break;
case AUDIO_SET_PCM_CONFIG:
D("AUDIO_SET_PCM_CONFIG\n");
rc = CAD_RES_SUCCESS;
break;
case AUDIO_GET_CONFIG:
if (copy_to_user((void *)arg, &p->cfg,
sizeof(struct msm_audio_config)))
return -EFAULT;
rc = CAD_RES_SUCCESS;
break;
case AUDIO_SET_CONFIG:
rc = copy_from_user(&p->cfg, (void *)arg,
sizeof(struct msm_audio_config));
if (rc)
D("cad_ioctl() SET_STREAM_CONFIG failed\n");
break;
case AUDIO_GET_AAC_CONFIG:
#ifndef CONFIG_AUDIO_AAC_PLUS
p->aac_cfg.sbr_on_flag = AUDIO_AAC_SBR_ON_FLAG_OFF;
#else
p->aac_cfg.sbr_on_flag = AUDIO_AAC_SBR_ON_FLAG_ON;
#endif
#ifndef CONFIG_AUDIO_ENHANCED_AAC_PLUS
p->aac_cfg.sbr_ps_on_flag = AUDIO_AAC_SBR_PS_ON_FLAG_OFF;
#else
p->aac_cfg.sbr_ps_on_flag = AUDIO_AAC_SBR_PS_ON_FLAG_ON;
#endif
if (copy_to_user((void *)arg, &p->aac_cfg,
sizeof(struct msm_audio_aac_config)))
return -EFAULT;
rc = CAD_RES_SUCCESS;
break;
case AUDIO_SET_AAC_CONFIG:
if (copy_from_user(&ncfg, (void *)arg,
sizeof(struct msm_audio_aac_config)))
return -EFAULT;
p->aac_cfg.channel_configuration = ncfg.channel_configuration;
p->aac_cfg.format = ncfg.format;
p->aac_cfg.ep_config = ncfg.ep_config;
p->aac_cfg.aac_section_data_resilience_flag =
ncfg.aac_section_data_resilience_flag;
p->aac_cfg.aac_scalefactor_data_resilience_flag =
ncfg.aac_scalefactor_data_resilience_flag;
p->aac_cfg.aac_spectral_data_resilience_flag =
ncfg.aac_spectral_data_resilience_flag;
#ifndef CONFIG_AUDIO_AAC_PLUS
p->aac_cfg.sbr_on_flag = AUDIO_AAC_SBR_ON_FLAG_OFF;
#else
p->aac_cfg.sbr_on_flag = ncfg.sbr_on_flag;
#endif
#ifndef CONFIG_AUDIO_ENHANCED_AAC_PLUS
p->aac_cfg.sbr_ps_on_flag = AUDIO_AAC_SBR_PS_ON_FLAG_OFF;
#else
p->aac_cfg.sbr_ps_on_flag = ncfg.sbr_ps_on_flag;
#endif
if ((ncfg.audio_object == CAD_AUDIO_OBJ_TYPE_AAC_LC)
|| (ncfg.audio_object == CAD_AUDIO_OBJ_TYPE_AAC_LTP)
|| (ncfg.audio_object == CAD_AUDIO_OBJ_TYPE_ER_AAC_LC)
|| (ncfg.audio_object == CAD_AUDIO_OBJ_TYPE_AAC_BSAC))
p->aac_cfg.audio_object = ncfg.audio_object;
rc = CAD_RES_SUCCESS;
break;
case AUDIO_SET_VOLUME:
rc = copy_from_user(&p->volume, (void *)arg, sizeof(u32));
memset(&cad_strm_volume, 0,
sizeof(struct cad_flt_cfg_strm_vol));
cad_strm_volume.volume = p->volume;
flt.filter_type = CAD_DEVICE_FILTER_TYPE_VOL;
flt.format_block = &cad_strm_volume;
flt.cmd = CAD_FILTER_CONFIG_STREAM_VOLUME;
flt.format_block_len =
sizeof(struct cad_flt_cfg_strm_vol);
rc = cad_ioctl(p->cad_w_handle,
CAD_IOCTL_CMD_SET_STREAM_FILTER_CONFIG,
&flt,
sizeof(struct cad_filter_struct));
if (rc) {
D("cad_ioctl() set volume failed\n");
break;
}
break;
case AUDIO_SET_EQ:
rc = copy_from_user(&cfs, (void *)arg,
sizeof(struct cad_filter_struct));
rc = cad_ioctl(p->cad_w_handle,
CAD_IOCTL_CMD_SET_STREAM_FILTER_CONFIG,
&cfs,
sizeof(struct cad_filter_struct));
if (rc)
pr_err("cad_ioctl() set equalizer failed\n");
break;
default:
D("unknown ioctl: 0x%08X\n", cmd);
rc = CAD_RES_SUCCESS;
}
return rc;
}
static int qsd_pcm_capture_prepare(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct qsd_audio *prtd = runtime->private_data;
int rc = 0;
struct cad_stream_device_struct_type cad_stream_dev;
struct cad_stream_info_struct_type cad_stream_info;
struct cad_write_pcm_format_struct_type cad_write_pcm_fmt;
u32 stream_device[1];
prtd->pcm_size = snd_pcm_lib_buffer_bytes(substream);
prtd->pcm_count = snd_pcm_lib_period_bytes(substream);
prtd->pcm_irq_pos = 0;
prtd->pcm_buf_pos = 0;
cad_stream_info.app_type = CAD_STREAM_APP_RECORD;
cad_stream_info.priority = 0;
cad_stream_info.buf_mem_type = CAD_STREAM_BUF_MEM_HEAP;
cad_stream_info.ses_buf_max_size = prtd->pcm_count;
if (prtd->enabled)
return 0;
mutex_lock(&the_locks.lock);
rc = cad_ioctl(prtd->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_INFO,
&cad_stream_info,
sizeof(struct cad_stream_info_struct_type));
if (rc) {
mutex_unlock(&the_locks.lock);
return rc;
}
cad_write_pcm_fmt.us_ver_id = CAD_WRITE_PCM_VERSION_10;
cad_write_pcm_fmt.pcm.us_sample_rate =
convert_dsp_samp_index(runtime->rate);
cad_write_pcm_fmt.pcm.us_channel_config = runtime->channels;
cad_write_pcm_fmt.pcm.us_width = 1;
cad_write_pcm_fmt.pcm.us_sign = 0;
rc = cad_ioctl(prtd->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_CONFIG,
&cad_write_pcm_fmt,
sizeof(struct cad_write_pcm_format_struct_type));
if (rc) {
mutex_unlock(&the_locks.lock);
return rc;
}
stream_device[0] = CAD_HW_DEVICE_ID_DEFAULT_TX ;
cad_stream_dev.device = (u32 *) &stream_device[0];
cad_stream_dev.device_len = 1;
rc = cad_ioctl(prtd->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_DEVICE,
&cad_stream_dev,
sizeof(struct cad_stream_device_struct_type));
if (rc) {
mutex_unlock(&the_locks.lock);
return rc;
}
rc = cad_ioctl(prtd->cad_w_handle, CAD_IOCTL_CMD_STREAM_START,
NULL, 0);
mutex_unlock(&the_locks.lock);
if (!rc)
prtd->enabled = 1;
return rc;
}
int audio_switch_device(int new_device)
{
int rc;
struct msm8k_audio_dev_ctrl *ctrl = &g_ctrl;
struct cad_device_struct_type cad_dev;
int prev_force_spkr_mode = get_force_speaker_mode();
int prev_fm_mode = get_fm_mode();
D("%s\n", __func__);
memset(&cad_dev, 0, sizeof(struct cad_device_struct_type));
switch (new_device) {
case HANDSET_MIC:
cad_dev.device = CAD_HW_DEVICE_ID_HANDSET_MIC;
cad_dev.reserved = CAD_TX_DEVICE;
break;
case HANDSET_SPKR:
cad_dev.device = CAD_HW_DEVICE_ID_HANDSET_SPKR;
cad_dev.reserved = CAD_RX_DEVICE;
break;
case HEADSET_MIC:
cad_dev.device = CAD_HW_DEVICE_ID_HEADSET_MIC;
cad_dev.reserved = CAD_TX_DEVICE;
break;
case HEADSET_SPKR_MONO:
cad_dev.device = CAD_HW_DEVICE_ID_HEADSET_SPKR_MONO;
cad_dev.reserved = CAD_RX_DEVICE;
break;
case HEADSET_SPKR_STEREO:
cad_dev.device = CAD_HW_DEVICE_ID_HEADSET_SPKR_STEREO;
cad_dev.reserved = CAD_RX_DEVICE;
break;
case SPKR_PHONE_MIC:
cad_dev.device = CAD_HW_DEVICE_ID_SPKR_PHONE_MIC;
cad_dev.reserved = CAD_TX_DEVICE;
break;
case SPKR_PHONE_MONO:
cad_dev.device = CAD_HW_DEVICE_ID_SPKR_PHONE_MONO;
cad_dev.reserved = CAD_RX_DEVICE;
break;
case SPKR_PHONE_STEREO:
cad_dev.device = CAD_HW_DEVICE_ID_SPKR_PHONE_STEREO;
cad_dev.reserved = CAD_RX_DEVICE;
break;
case BT_SCO_MIC:
cad_dev.device = CAD_HW_DEVICE_ID_BT_SCO_MIC;
cad_dev.reserved = CAD_TX_DEVICE;
break;
case BT_SCO_SPKR:
cad_dev.device = CAD_HW_DEVICE_ID_BT_SCO_SPKR;
cad_dev.reserved = CAD_RX_DEVICE;
break;
case BT_A2DP_SPKR:
cad_dev.device = CAD_HW_DEVICE_ID_BT_A2DP_SPKR;
cad_dev.reserved = CAD_RX_DEVICE;
break;
case TTY_HEADSET_MIC:
cad_dev.device = CAD_HW_DEVICE_ID_TTY_HEADSET_MIC;
cad_dev.reserved = CAD_TX_DEVICE;
break;
case TTY_HEADSET_SPKR:
cad_dev.device = CAD_HW_DEVICE_ID_TTY_HEADSET_SPKR;
cad_dev.reserved = CAD_RX_DEVICE;
break;
case HEADSET_MONO_PLUS_SPKR_MONO_RX:
cad_dev.device =
CAD_HW_DEVICE_ID_HEADSET_MONO_PLUS_SPKR_MONO_RX;
cad_dev.reserved = CAD_RX_DEVICE;
break;
case HEADSET_MONO_PLUS_SPKR_STEREO_RX:
cad_dev.device =
CAD_HW_DEVICE_ID_HEADSET_MONO_PLUS_SPKR_STEREO_RX;
cad_dev.reserved = CAD_RX_DEVICE;
break;
case HEADSET_STEREO_PLUS_SPKR_MONO_RX:
cad_dev.device =
CAD_HW_DEVICE_ID_HEADSET_STEREO_PLUS_SPKR_MONO_RX;
cad_dev.reserved = CAD_RX_DEVICE;
break;
case HEADSET_STEREO_PLUS_SPKR_STEREO_RX:
cad_dev.device =
CAD_HW_DEVICE_ID_HEADSET_STEREO_PLUS_SPKR_STEREO_RX;
cad_dev.reserved = CAD_RX_DEVICE;
break;
case I2S_RX:
cad_dev.device = CAD_HW_DEVICE_ID_I2S_RX;
cad_dev.reserved = CAD_RX_DEVICE;
break;
case I2S_TX:
cad_dev.device = CAD_HW_DEVICE_ID_I2S_TX;
cad_dev.reserved = CAD_TX_DEVICE;
break;
case SPKR_PHONE_HEADSET_STEREO:
cad_dev.device = CAD_HW_DEVICE_ID_HEADSET_SPKR_STEREO;
cad_dev.reserved = CAD_RX_DEVICE;
break;
case FM_HEADSET:
cad_dev.device = CAD_HW_DEVICE_ID_HEADSET_SPKR_STEREO;
cad_dev.reserved = CAD_RX_DEVICE;
break;
case FM_SPKR:
cad_dev.device = CAD_HW_DEVICE_ID_SPKR_PHONE_STEREO;
cad_dev.reserved = CAD_RX_DEVICE;
break;
default:
return -ENODEV;
}
/* Set and check if force_speaker_mode is changed */
if (cad_dev.reserved == CAD_RX_DEVICE) {
if (new_device == SPKR_PHONE_HEADSET_STEREO)
set_force_speaker_mode(1);
else
set_force_speaker_mode(0);
if (new_device == FM_HEADSET)
set_fm_mode(1);
else if (new_device == FM_SPKR)
set_fm_mode(2);
else
set_fm_mode(0);
}
if (prev_force_spkr_mode != get_force_speaker_mode() ||
prev_fm_mode != get_fm_mode())
cad_dev.force_update = 1;
pr_info("SWITCH DEVICE %d\n", cad_dev.device);
rc = cad_ioctl(ctrl->cad_ctrl_handle,
CAD_IOCTL_CMD_DEVICE_SET_GLOBAL_DEFAULT,
&cad_dev,
sizeof(struct cad_device_struct_type));
if (rc) {
pr_err("cad_ioctl() SET_GLOBAL_DEFAULT failed\n");
return rc;
}
if (cad_dev.reserved == CAD_RX_DEVICE)
ctrl->current_rx_device = cad_dev.device;
else
ctrl->current_tx_device = cad_dev.device;
#if 1
if (cad_dev.reserved == CAD_TX_DEVICE) {
struct msm_mute_info info;
info.path = 1;
info.mute = 0;
pr_info("UNMUTE DEVICE %d\n", cad_dev.device);
audio_set_device_mute(&info);
}
#else
if (cad_dev.reserved == CAD_TX_DEVICE &&
atomic_read(&tx_mute)) {
/* keep tx mute status if path is changed. */
struct msm_mute_info info;
info.path = info.mute = 1;
pr_info("MUTE DEVICE %d\n", cad_dev.device);
audio_set_device_mute(&info);
}
#endif
return rc;
}
static int msm8k_pcm_in_ioctl(struct inode *inode, struct file *f,
unsigned int cmd, unsigned long arg)
{
int rc = CAD_RES_SUCCESS;
struct pcm *p = f->private_data;
void *cad_arg = (void *)arg;
u32 stream_device[1];
struct cad_device_struct_type cad_dev;
struct cad_stream_device_struct_type cad_stream_dev;
struct cad_stream_info_struct_type cad_stream_info;
struct cad_write_pcm_format_struct_type cad_write_pcm_fmt;
D("%s\n", __func__);
memset(&cad_dev, 0, sizeof(struct cad_device_struct_type));
memset(&cad_stream_dev, 0,
sizeof(struct cad_stream_device_struct_type));
memset(&cad_stream_info, 0, sizeof(struct cad_stream_info_struct_type));
memset(&cad_write_pcm_fmt, 0,
sizeof(struct cad_write_pcm_format_struct_type));
switch (cmd) {
case AUDIO_START:
cad_stream_info.app_type = CAD_STREAM_APP_RECORD;
cad_stream_info.priority = 0;
cad_stream_info.buf_mem_type = CAD_STREAM_BUF_MEM_HEAP;
cad_stream_info.ses_buf_max_size = p->cfg.buffer_size;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_INFO,
&cad_stream_info,
sizeof(struct cad_stream_info_struct_type));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_INFO failed\n");
break;
}
stream_device[0] = CAD_HW_DEVICE_ID_DEFAULT_TX;
cad_stream_dev.device = (u32 *)&stream_device[0];
cad_stream_dev.device_len = 1;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_DEVICE,
&cad_stream_dev,
sizeof(struct cad_stream_device_struct_type));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_DEVICE failed\n");
break;
}
cad_write_pcm_fmt.us_ver_id = CAD_WRITE_PCM_VERSION_10;
cad_write_pcm_fmt.pcm.us_channel_config = p->cfg.channel_count;
cad_write_pcm_fmt.pcm.us_width = 1;
cad_write_pcm_fmt.pcm.us_sign = 0;
switch (p->cfg.sample_rate) {
case 96000:
cad_write_pcm_fmt.pcm.us_sample_rate = 0;
break;
case 88200:
cad_write_pcm_fmt.pcm.us_sample_rate = 1;
break;
case 64000:
cad_write_pcm_fmt.pcm.us_sample_rate = 2;
break;
case 48000:
cad_write_pcm_fmt.pcm.us_sample_rate = 3;
break;
case 44100:
cad_write_pcm_fmt.pcm.us_sample_rate = 4;
break;
case 32000:
cad_write_pcm_fmt.pcm.us_sample_rate = 5;
break;
case 24000:
cad_write_pcm_fmt.pcm.us_sample_rate = 6;
break;
case 22050:
cad_write_pcm_fmt.pcm.us_sample_rate = 7;
break;
case 16000:
cad_write_pcm_fmt.pcm.us_sample_rate = 8;
break;
case 12000:
cad_write_pcm_fmt.pcm.us_sample_rate = 9;
break;
case 11025:
cad_write_pcm_fmt.pcm.us_sample_rate = 10;
break;
case 8000:
cad_write_pcm_fmt.pcm.us_sample_rate = 11;
break;
}
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_CONFIG,
&cad_write_pcm_fmt,
sizeof(struct cad_write_pcm_format_struct_type));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_CONFIG failed\n");
break;
}
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_START,
NULL, 0);
if (rc) {
pr_err("cad_ioctl() STREAM_START failed\n");
break;
}
break;
case AUDIO_STOP:
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_PAUSE,
cad_arg, sizeof(u32));
break;
case AUDIO_FLUSH:
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_FLUSH,
cad_arg, sizeof(u32));
break;
case AUDIO_GET_CONFIG:
if (copy_to_user((void *)arg, &p->cfg,
sizeof(struct msm_audio_config)))
return -EFAULT;
case AUDIO_SET_CONFIG:
rc = copy_from_user(&p->cfg, (void *)arg,
sizeof(struct msm_audio_config));
break;
default:
rc = -EINVAL;
}
return rc;
}
static int msm8k_mp3_ioctl(struct inode *inode, struct file *f,
unsigned int cmd, unsigned long arg)
{
int rc;
struct msm_audio_config cfg;
struct mp3 *p = f->private_data;
void *cad_arg = (void *)arg;
u32 stream_device[1];
struct cad_device_struct_type cad_dev;
struct cad_stream_device_struct_type cad_stream_dev;
struct cad_stream_info_struct_type cad_stream_info;
struct cad_write_mp3_format_struct_type cad_write_mp3_fmt;
struct cad_flt_cfg_strm_vol cad_strm_volume;
struct cad_filter_struct flt;
struct cad_event_struct_type eos_event;
struct cad_audio_eq_cfg eq;
u32 percentage;
D("%s\n", __func__);
memset(&cad_dev, 0, sizeof(struct cad_device_struct_type));
memset(&cad_stream_dev, 0,
sizeof(struct cad_stream_device_struct_type));
memset(&cad_stream_info, 0, sizeof(struct cad_stream_info_struct_type));
memset(&cad_write_mp3_fmt, 0,
sizeof(struct cad_write_mp3_format_struct_type));
memset(&cfg, 0, sizeof(struct msm_audio_config));
memset(&flt, 0, sizeof(struct cad_filter_struct));
switch (cmd) {
case AUDIO_START:
cad_stream_info.app_type = CAD_STREAM_APP_PLAYBACK;
cad_stream_info.priority = 0;
cad_stream_info.buf_mem_type = CAD_STREAM_BUF_MEM_HEAP;
cad_stream_info.ses_buf_max_size = 1024 * 11;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_INFO,
&cad_stream_info,
sizeof(struct cad_stream_info_struct_type));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_INFO failed\n");
break;
}
cad_write_mp3_fmt.ver_id = CAD_WRITE_MP3_VERSION_10;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_CONFIG,
&cad_write_mp3_fmt,
sizeof(struct cad_write_mp3_format_struct_type));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_CONFIG failed\n");
break;
}
eos_event.callback = &msm8k_mp3_eos_event_cb;
eos_event.client_data = p;
rc = cad_ioctl(p->cad_w_handle,
CAD_IOCTL_CMD_SET_STREAM_EVENT_LSTR,
&eos_event,
sizeof(struct cad_event_struct_type));
if (rc) {
D("cad_ioctl() SET_STREAM_EVENT_LSTR failed\n");
break;
}
stream_device[0] = CAD_HW_DEVICE_ID_DEFAULT_RX;
cad_stream_dev.device = (u32 *)&stream_device[0];
cad_stream_dev.device_len = 1;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_DEVICE,
&cad_stream_dev,
sizeof(struct cad_stream_device_struct_type));
if (rc) {
pr_err("cad_ioctl() SET_STREAM_DEVICE failed\n");
break;
}
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_START,
NULL, 0);
if (rc) {
pr_err("cad_ioctl() STREAM_START failed\n");
break;
}
break;
case AUDIO_STOP:
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_PAUSE,
NULL, 0);
break;
case AUDIO_FLUSH:
p->flush_rcvd = 1;
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_STREAM_FLUSH,
NULL, 0);
wake_up(&p->eos_wait);
p->flush_rcvd = 0;
break;
case AUDIO_GET_CONFIG:
/* hard-coded until we support this in the CAD */
cfg.buffer_size = 4096;
cfg.buffer_count = 2;
cfg.channel_count = 1;
cfg.sample_rate = 48000;
if (copy_to_user((void *)arg, &cfg,
sizeof(struct msm_audio_config)))
return -EFAULT;
rc = CAD_RES_SUCCESS;
break;
case AUDIO_SET_CONFIG:
rc = cad_ioctl(p->cad_w_handle, CAD_IOCTL_CMD_SET_STREAM_CONFIG,
cad_arg, sizeof(u32));
break;
case AUDIO_SET_VOLUME:
rc = copy_from_user(&percentage, (void *)arg, sizeof(u32));
p->volume = qdsp6_stream_volume_mapping(percentage);
memset(&cad_strm_volume, 0,
sizeof(struct cad_flt_cfg_strm_vol));
cad_strm_volume.volume = p->volume;
flt.filter_type = CAD_DEVICE_FILTER_TYPE_VOL;
flt.format_block = &cad_strm_volume;
flt.cmd = CAD_FILTER_CONFIG_STREAM_VOLUME;
flt.format_block_len =
sizeof(struct cad_flt_cfg_strm_vol);
rc = cad_ioctl(p->cad_w_handle,
CAD_IOCTL_CMD_SET_STREAM_FILTER_CONFIG,
&flt,
sizeof(struct cad_filter_struct));
if (rc) {
pr_err("cad_ioctl() set volume failed\n");
break;
}
break;
case AUDIO_SET_EQ:
rc = copy_from_user(&eq, (void *)arg,
sizeof(struct cad_audio_eq_cfg));
flt.filter_type = CAD_DEVICE_FILTER_TYPE_EQ;
flt.cmd = CAD_FILTER_EQ_STREAM_CONFIG;
flt.format_block_len = sizeof(struct cad_audio_eq_cfg);
flt.format_block = &eq;
rc = cad_ioctl(p->cad_w_handle,
CAD_IOCTL_CMD_SET_STREAM_FILTER_CONFIG,
&flt,
sizeof(struct cad_filter_struct));
if (rc)
pr_err("cad_ioctl() set equalizer failed\n");
break;
default:
rc = -EINVAL;
}
return rc;
}
