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__);
}
static int msm8k_amr_open(struct inode *inode, struct file *f)
{
struct amr *amr;
struct cad_open_struct_type cos;
D("%s\n", __func__);
amr = kmalloc(sizeof(struct amr), GFP_KERNEL);
if (amr == NULL) {
pr_err("Could not allocate memory for amr driver\n");
return CAD_RES_FAILURE;
}
f->private_data = amr;
memset(amr, 0, sizeof(struct amr));
cos.format = CAD_FORMAT_AMRNB;
cos.op_code = CAD_OPEN_OP_WRITE;
amr->cad_w_handle = cad_open(&cos);
if (amr->cad_w_handle == 0)
return CAD_RES_FAILURE;
else
return CAD_RES_SUCCESS;
}
static int msm8k_aac_in_open(struct inode *inode, struct file *f)
{
struct aac *aac;
struct cad_open_struct_type cos;
D("%s\n", __func__);
aac = kmalloc(sizeof(struct aac), GFP_KERNEL);
if (aac == NULL) {
pr_err("Could not allocate memory for aac recording driver\n");
return CAD_RES_FAILURE;
}
f->private_data = aac;
memset(aac, 0, sizeof(struct aac));
aac->str_cfg.buffer_size = 4096;
aac->str_cfg.buffer_count = 2;
aac->aac_cfg.channels = 1;
aac->aac_cfg.sample_rate = 48000;
aac->aac_cfg.bit_rate = 192000;
aac->aac_cfg.stream_format = AUDIO_AAC_FORMAT_ADTS;
cos.format = CAD_FORMAT_AAC;
cos.op_code = CAD_OPEN_OP_READ;
aac->cad_w_handle = cad_open(&cos);
if (aac->cad_w_handle == 0)
return CAD_RES_FAILURE;
else
return CAD_RES_SUCCESS;
}
static int msm8k_qcelp_in_open(struct inode *inode, struct file *f)
{
struct qcelp *qcelp;
struct cad_open_struct_type cos;
D("%s\n", __func__);
qcelp = kmalloc(sizeof(struct qcelp), GFP_KERNEL);
if (qcelp == NULL) {
pr_err("Could not allocate memory for qcelp rec driver\n");
return CAD_RES_FAILURE;
}
f->private_data = qcelp;
memset(qcelp, 0, sizeof(struct qcelp));
qcelp->cfg.channels = 1;
qcelp->cfg.cdma_rate = CDMA_RATE_FULL;
qcelp->cfg.min_bit_rate = 1;
qcelp->cfg.max_bit_rate = 4;
cos.format = CAD_FORMAT_QCELP13K;
cos.op_code = CAD_OPEN_OP_READ;
qcelp->cad_w_handle = cad_open(&cos);
qcelp->voicerec_mode.rec_mode = VOC_REC_UPLINK;
if (qcelp->cad_w_handle == 0) {
kfree(qcelp);
return -ENODEV;
} else
return 0;
}
static int msm8k_mp3_open(struct inode *inode, struct file *f)
{
struct mp3 *mp3;
struct cad_open_struct_type cos;
D("%s\n", __func__);
mp3 = kmalloc(sizeof(struct mp3), GFP_KERNEL);
if (mp3 == NULL) {
pr_err("Could not allocate memory for mp3 driver\n");
return CAD_RES_FAILURE;
}
f->private_data = mp3;
memset(mp3, 0, sizeof(struct mp3));
mp3->eos_ack = 0;
mp3->flush_rcvd = 0;
mutex_init(&mp3->write_lock);
init_waitqueue_head(&mp3->eos_wait);
cos.format = CAD_FORMAT_MP3;
cos.op_code = CAD_OPEN_OP_WRITE;
mp3->cad_w_handle = cad_open(&cos);
if (mp3->cad_w_handle == 0)
return CAD_RES_FAILURE;
else
return CAD_RES_SUCCESS;
}
static int msm8k_pcm_open(struct inode *inode, struct file *f)
{
struct pcm *pcm;
struct cad_open_struct_type cos;
int rc;
D("%s\n", __func__);
mutex_lock(&pcm_lock);
if (pcm_opened) {
pr_err("pcm: busy\n");
rc = -EBUSY;
goto done;
}
pcm = kmalloc(sizeof(struct pcm), GFP_KERNEL);
if (pcm == NULL) {
pr_err("Could not allocate memory for pcm driver\n");
return CAD_RES_FAILURE;
}
f->private_data = pcm;
memset(pcm, 0, sizeof(struct pcm));
pcm->cfg.buffer_size = 4096;
pcm->cfg.buffer_count = 2;
pcm->cfg.channel_count = 1;
pcm->cfg.sample_rate = 48000;
audio_prevent_sleep();
cos.format = CAD_FORMAT_PCM;
cos.op_code = CAD_OPEN_OP_WRITE;
pcm->cad_w_handle = cad_open(&cos);
if (pcm->cad_w_handle == 0) {
audio_allow_sleep();
rc = CAD_RES_FAILURE;
} else {
pcm_opened = 1;
rc = CAD_RES_SUCCESS;
}
done:
mutex_unlock(&pcm_lock);
return rc;
}
static int msm8k_pcm_in_open(struct inode *inode, struct file *f)
{
struct pcm *pcm = &g_pcm_in;
struct cad_open_struct_type cos;
D("%s\n", __func__);
cos.format = CAD_FORMAT_PCM;
f->private_data = pcm;
cos.op_code = CAD_OPEN_OP_READ;
pcm->cad_w_handle = cad_open(&cos);
if (pcm->cad_w_handle == 0)
return CAD_RES_FAILURE;
else
return CAD_RES_SUCCESS;
}
static int msm8k_dtmf_open(struct inode *inode, struct file *f)
{
struct dtmf *dtmf = &g_dtmf;
struct cad_open_struct_type cos;
D("%s\n", __func__);
cos.format = CAD_FORMAT_DTMF;
f->private_data = dtmf;
cos.op_code = CAD_OPEN_OP_WRITE;
dtmf->cad_w_handle = cad_open(&cos);
if (dtmf->cad_w_handle == 0)
return CAD_RES_FAILURE;
else
return CAD_RES_SUCCESS;
}
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_open(struct inode *inode, struct file *f)
{
struct aac *aac;
struct cad_open_struct_type cos;
D("%s\n", __func__);
aac = kmalloc(sizeof(struct aac), GFP_KERNEL);
if (aac == NULL) {
pr_err("Could not allocate memory for aac driver\n");
return CAD_RES_FAILURE;
}
f->private_data = aac;
memset(aac, 0, sizeof(struct aac));
aac->cfg.buffer_size = 4096;
aac->cfg.buffer_count = 2;
aac->cfg.channel_count = 1;
/* This sample rate will be converted to the CAD value upon start. */
aac->cfg.sample_rate = 48000;
aac->aac_cfg.format = CAD_BLK_FMT_ADTS;
aac->aac_cfg.audio_object = CAD_AUDIO_OBJ_TYPE_AAC_LC;
aac->aac_cfg.ep_config = CAD_ERR_PROT_SCHEME_0;
aac->aac_cfg.channel_configuration = CAD_CHANNEL_CFG_MONO;
aac->eos_ack = 0;
aac->flush_rcvd = 0;
mutex_init(&aac->write_lock);
init_waitqueue_head(&aac->eos_wait);
cos.format = CAD_FORMAT_AAC;
cos.op_code = CAD_OPEN_OP_WRITE;
aac->cad_w_handle = cad_open(&cos);
if (aac->cad_w_handle == 0)
return CAD_RES_FAILURE;
else
return CAD_RES_SUCCESS;
}
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;
}
