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; }