static int audqcelp_in_open(struct inode *inode, struct file *file)
{
struct audio_in *audio = &the_audio_qcelp_in;
int rc;
int encid;
MM_DBG("\n");
mutex_lock(&audio->lock);
if (audio->opened) {
rc = -EBUSY;
goto done;
}
if ((file->f_mode & FMODE_WRITE) &&
(file->f_mode & FMODE_READ)) {
rc = -EACCES;
MM_ERR("Non tunnel encoding is not supported\n");
goto done;
} else if (!(file->f_mode & FMODE_WRITE) &&
(file->f_mode & FMODE_READ)) {
audio->mode = MSM_AUD_ENC_MODE_TUNNEL;
MM_DBG("Opened for tunnel mode encoding\n");
} else {
rc = -EACCES;
goto done;
}
/* Settings will be re-config at AUDIO_SET_CONFIG,
* but at least we need to have initial config
*/
audio->buffer_size = (FRAME_SIZE - 8);
audio->enc_type = ENC_TYPE_V13K | audio->mode;
audio->cfg.cdma_rate = CDMA_RATE_FULL;
audio->cfg.min_bit_rate = CDMA_RATE_FULL;
audio->cfg.max_bit_rate = CDMA_RATE_FULL;
audio->source = INTERNAL_CODEC_TX_SOURCE_MIX_MASK;
audio->rec_mode = VOC_REC_UPLINK;
encid = audpreproc_aenc_alloc(audio->enc_type, &audio->module_name,
&audio->queue_ids);
if (encid < 0) {
MM_ERR("No free encoder available\n");
rc = -ENODEV;
goto done;
}
audio->enc_id = encid;
rc = msm_adsp_get(audio->module_name, &audio->audrec,
&audrec_qcelp_adsp_ops, audio);
if (rc) {
audpreproc_aenc_free(audio->enc_id);
goto done;
}
audio->stopped = 0;
audio->source = 0;
#ifdef CONFIG_SH_AUDIO_DRIVER
audio->readbreak = 0;
#endif /* CONFIG_SH_AUDIO_DRIVER */
audqcelp_in_flush(audio);
audio->device_events = AUDDEV_EVT_DEV_RDY | AUDDEV_EVT_DEV_RLS |
AUDDEV_EVT_VOICE_STATE_CHG;
audio->voice_state = msm_get_voice_state();
rc = auddev_register_evt_listner(audio->device_events,
AUDDEV_CLNT_ENC, audio->enc_id,
qcelp_in_listener, (void *) audio);
if (rc) {
MM_ERR("failed to register device event listener\n");
goto evt_error;
}
file->private_data = audio;
audio->opened = 1;
done:
mutex_unlock(&audio->lock);
return rc;
evt_error:
msm_adsp_put(audio->audrec);
audpreproc_aenc_free(audio->enc_id);
mutex_unlock(&audio->lock);
return rc;
}
static int audpcm_in_open(struct inode *inode, struct file *file)
{
struct audio_in *audio;
const char *modname;
int rc;
audio = kzalloc(sizeof(struct audio_in), GFP_KERNEL);
if (!audio) return -ENOMEM;
#ifdef TEST_ONLY
current_audio_in = audio;
#endif
audio->phys = pmem_kalloc(DMASZ, PMEM_MEMTYPE_EBI1 | PMEM_ALIGNMENT_4K);
if (!IS_ERR((void *) audio->phys)) {
audio->data = ioremap(audio->phys, DMASZ);
if (!audio->data) {
MM_AUD_ERR("Could not remap DMA buffers\n");
pmem_kfree(audio->phys);
kfree(audio);
return -ENOMEM;
}
} else {
MM_AUD_ERR("Could not allocate DMA buffers\n");
kfree(audio);
return -ENOMEM;
}
audio->enc_id = audpreproc_aenc_alloc(ENC_TYPE_WAV | MSM_AUD_ENC_MODE_TUNNEL,
&modname, &audio->queue_ids);
if (audio->enc_id < 0) {
MM_AUD_ERR("No free encoder available\n");
rc = -ENODEV;
goto no_aenc;
}
MM_DBG("allocated encoder %d, module %s\n", audio->enc_id, modname);
rc = auddev_register_evt_listner(AUDDEV_EVT_DEV_RDY | AUDDEV_EVT_DEV_RLS |
AUDDEV_EVT_FREQ_CHG | AUDDEV_EVT_VOICE_STATE_CHG,
AUDDEV_CLNT_ENC, audio->enc_id,
audpcm_in_listener, audio);
if (rc) {
MM_AUD_ERR("failed to register device event listener\n");
goto evt_error;
}
rc = msm_adsp_get(modname, &audio->audrec, &audrec_adsp_ops, audio);
if (rc) {
MM_AUD_ERR("Failed to get AUDREC task\n");
goto no_audrec;
}
if(!audio->audrec) {
MM_AUD_ERR("Null AUDREC task returned by ADSP\n");
rc = -EFAULT;
goto no_audrec;
}
audio->source = INTERNAL_CODEC_TX_SOURCE_MIX_MASK;
audio->channel_mode = AUDREC_CMD_MODE_MONO;
audio->buffer_size = MONO_DATA_SIZE;
audio->samp_rate = 8000;
audio->stopped = 0;
audio->running = 0;
audio->enabled = 0;
audpcm_in_flush(audio);
mutex_init(&audio->lock);
mutex_init(&audio->read_lock);
spin_lock_init(&audio->dsp_lock);
spin_lock_init(&audio->dev_lock);
init_waitqueue_head(&audio->wait);
init_waitqueue_head(&audio->wait_enable);
init_waitqueue_head(&audio->wait_voice_incall);
init_waitqueue_head(&audio->wait_rec_cfg);
audio->voice_state = msm_get_voice_state();
file->private_data = audio;
return rc;
no_audrec:
auddev_unregister_evt_listner(AUDDEV_CLNT_ENC, audio->enc_id);
evt_error:
audpreproc_aenc_free(audio->enc_id);
no_aenc:
iounmap(audio->data);
pmem_kfree(audio->phys);
kfree(audio);
return rc;
}
static int auda2dp_in_open(struct inode *inode, struct file *file)
{
struct audio_a2dp_in *audio = &the_audio_a2dp_in;
int rc;
int encid;
mutex_lock(&audio->lock);
if (audio->opened) {
rc = -EBUSY;
goto done;
}
audio->phys = allocate_contiguous_ebi_nomap(DMASZ, SZ_4K);
if (audio->phys) {
audio->msm_map = ioremap(audio->phys, DMASZ);
if (IS_ERR(audio->msm_map)) {
MM_ERR("could not map the phys address to kernel"
"space\n");
rc = -ENOMEM;
free_contiguous_memory_by_paddr(audio->phys);
goto done;
}
audio->data = (u8 *)audio->msm_map;
} else {
MM_ERR("could not allocate DMA buffers\n");
rc = -ENOMEM;
goto done;
}
MM_DBG("Memory addr = 0x%8x phy addr = 0x%8x\n",\
(int) audio->data, (int) audio->phys);
if ((file->f_mode & FMODE_WRITE) &&
(file->f_mode & FMODE_READ)) {
rc = -EACCES;
MM_ERR("Non tunnel encoding is not supported\n");
goto done;
} else if (!(file->f_mode & FMODE_WRITE) &&
(file->f_mode & FMODE_READ)) {
audio->mode = MSM_AUD_ENC_MODE_TUNNEL;
MM_DBG("Opened for Tunnel mode encoding\n");
} else {
rc = -EACCES;
goto done;
}
/* Settings will be re-config at AUDIO_SET_CONFIG/SBC_ENC_CONFIG,
* but at least we need to have initial config
*/
audio->channel_mode = AUDREC_CMD_MODE_MONO;
audio->buffer_size = FRAME_SIZE_SBC;
audio->samp_rate = 48000;
audio->enc_type = ENC_TYPE_SBC | audio->mode;
audio->cfg.bit_allocation = AUDIO_SBC_BA_SNR;
audio->cfg.mode = AUDIO_SBC_MODE_JSTEREO;
audio->cfg.number_of_subbands = AUDIO_SBC_BANDS_8;
audio->cfg.number_of_blocks = AUDIO_SBC_BLOCKS_16;
audio->cfg.bit_rate = 320000; /* max 512kbps(mono), 320kbs(others) */
encid = audpreproc_aenc_alloc(audio->enc_type, &audio->module_name,
&audio->queue_ids);
if (encid < 0) {
MM_ERR("No free encoder available\n");
rc = -ENODEV;
goto done;
}
audio->enc_id = encid;
rc = msm_adsp_get(audio->module_name, &audio->audrec,
&audrec_adsp_ops, audio);
if (rc) {
audpreproc_aenc_free(audio->enc_id);
goto done;
}
audio->stopped = 0;
audio->source = 0;
audio->abort = 0;
auda2dp_in_flush(audio);
audio->device_events = AUDDEV_EVT_DEV_RDY | AUDDEV_EVT_DEV_RLS |
AUDDEV_EVT_FREQ_CHG;
rc = auddev_register_evt_listner(audio->device_events,
AUDDEV_CLNT_ENC, audio->enc_id,
a2dp_in_listener, (void *) audio);
if (rc) {
MM_ERR("failed to register device event listener\n");
goto evt_error;
}
audio->build_id = socinfo_get_build_id();
MM_DBG("Modem build id = %s\n", audio->build_id);
file->private_data = audio;
audio->opened = 1;
rc = 0;
done:
mutex_unlock(&audio->lock);
return rc;
evt_error:
msm_adsp_put(audio->audrec);
audpreproc_aenc_free(audio->enc_id);
mutex_unlock(&audio->lock);
return rc;
}
static int audamrnb_in_open(struct inode *inode, struct file *file)
{
struct audio_in *audio = &the_audio_amrnb_in;
int rc;
int encid;
mutex_lock(&audio->lock);
if (audio->opened) {
rc = -EBUSY;
goto done;
}
audio->phys = pmem_kalloc(DMASZ, PMEM_MEMTYPE_EBI1|
PMEM_ALIGNMENT_4K);
if (!IS_ERR((void *)audio->phys)) {
audio->data = ioremap(audio->phys, DMASZ);
if (!audio->data) {
pr_aud_err("could not allocate DMA buffers\n");
rc = -ENOMEM;
pmem_kfree(audio->phys);
goto done;
}
} else {
pr_aud_err("could not allocate DMA buffers\n");
rc = -ENOMEM;
goto done;
}
MM_DBG("Memory addr = 0x%8x phy addr = 0x%8x\n",\
(int) audio->data, (int) audio->phys);
if ((file->f_mode & FMODE_WRITE) &&
(file->f_mode & FMODE_READ)) {
rc = -EACCES;
pr_aud_err("Non tunnel encoding is not supported\n");
goto done;
} else if (!(file->f_mode & FMODE_WRITE) &&
(file->f_mode & FMODE_READ)) {
audio->mode = MSM_AUD_ENC_MODE_TUNNEL;
MM_DBG("Opened for tunnel mode encoding\n");
} else {
rc = -EACCES;
goto done;
}
/* Settings will be re-config at AUDIO_SET_CONFIG,
* but at least we need to have initial config
*/
audio->buffer_size = (FRAME_SIZE - 8);
audio->enc_type = ENC_TYPE_AMRNB | audio->mode;
audio->dtx_mode = -1;
audio->frame_format = 0;
audio->used_mode = 7; /* Bit Rate 12.2 kbps MR122 */
encid = audpreproc_aenc_alloc(audio->enc_type, &audio->module_name,
&audio->queue_ids);
if (encid < 0) {
pr_aud_err("No free encoder available\n");
rc = -ENODEV;
goto done;
}
audio->enc_id = encid;
rc = msm_adsp_get(audio->module_name, &audio->audrec,
&audrec_amrnb_adsp_ops, audio);
if (rc) {
audpreproc_aenc_free(audio->enc_id);
goto done;
}
audio->stopped = 0;
audio->source = 0;
audamrnb_in_flush(audio);
audio->device_events = AUDDEV_EVT_DEV_RDY | AUDDEV_EVT_DEV_RLS |
AUDDEV_EVT_VOICE_STATE_CHG;
audio->voice_state = VOICE_STATE_INCALL;
rc = auddev_register_evt_listner(audio->device_events,
AUDDEV_CLNT_ENC, audio->enc_id,
amrnb_in_listener, (void *) audio);
if (rc) {
pr_aud_err("failed to register device event listener\n");
goto evt_error;
}
file->private_data = audio;
audio->opened = 1;
done:
mutex_unlock(&audio->lock);
return rc;
evt_error:
msm_adsp_put(audio->audrec);
audpreproc_aenc_free(audio->enc_id);
mutex_unlock(&audio->lock);
return rc;
}
static int audpcm_in_open(struct inode *inode, struct file *file)
{
struct audio_in *audio = &the_audio_in;
int rc;
int encid;
struct timespec ts;
struct rtc_time tm;
mutex_lock(&audio->lock);
if (audio->opened) {
rc = -EBUSY;
goto done;
}
/* Settings will be re-config at AUDIO_SET_CONFIG,
* but at least we need to have initial config
*/
audio->channel_mode = AUDREC_CMD_MODE_MONO;
audio->buffer_size = MONO_DATA_SIZE;
audio->samp_rate = 8000;
audio->enc_type = ENC_TYPE_WAV | audio->mode;
audio->source = INTERNAL_CODEC_TX_SOURCE_MIX_MASK;
encid = audpreproc_aenc_alloc(audio->enc_type, &audio->module_name,
&audio->queue_ids);
if (encid < 0) {
MM_AUD_ERR("No free encoder available\n");
rc = -ENODEV;
goto done;
}
audio->enc_id = encid;
rc = msm_adsp_get(audio->module_name, &audio->audrec,
&audrec_adsp_ops, audio);
if (rc) {
audpreproc_aenc_free(audio->enc_id);
goto done;
}
audio->stopped = 0;
audio->source = 0;
audio->abort = 0;
audpcm_in_flush(audio);
audio->device_events = AUDDEV_EVT_DEV_RDY | AUDDEV_EVT_DEV_RLS |
AUDDEV_EVT_FREQ_CHG;
rc = auddev_register_evt_listner(audio->device_events,
AUDDEV_CLNT_ENC, audio->enc_id,
pcm_in_listener, (void *) audio);
if (rc) {
MM_AUD_ERR("failed to register device event listener\n");
goto evt_error;
}
file->private_data = audio;
audio->opened = 1;
rc = 0;
done:
mutex_unlock(&audio->lock);
getnstimeofday(&ts);
rtc_time_to_tm(ts.tv_sec, &tm);
pr_aud_info1("[ATS][start_recording][successful] at %lld \
(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n",
ktime_to_ns(ktime_get()),
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
return rc;
evt_error:
msm_adsp_put(audio->audrec);
audpreproc_aenc_free(audio->enc_id);
mutex_unlock(&audio->lock);
return rc;
}
static int audamrnb_in_open(struct inode *inode, struct file *file)
{
struct audio_in *audio = &the_audio_amrnb_in;
int rc;
int encid;
int len = 0;
unsigned long ionflag = 0;
ion_phys_addr_t addr = 0;
struct ion_handle *handle = NULL;
struct ion_client *client = NULL;
mutex_lock(&audio->lock);
if (audio->opened) {
rc = -EBUSY;
goto done;
}
client = msm_ion_client_create(UINT_MAX, "Audio_AMR_In_Client");
if (IS_ERR_OR_NULL(client)) {
MM_ERR("Unable to create ION client\n");
rc = -ENOMEM;
goto client_create_error;
}
audio->client = client;
handle = ion_alloc(client, DMASZ, SZ_4K,
ION_HEAP(ION_AUDIO_HEAP_ID),0);
if (IS_ERR_OR_NULL(handle)) {
MM_ERR("Unable to create allocate O/P buffers\n");
rc = -ENOMEM;
goto buff_alloc_error;
}
audio->buff_handle = handle;
rc = ion_phys(client, handle, &addr, &len);
if (rc) {
MM_ERR("O/P buffers:Invalid phy: %x sz: %x\n",
(unsigned int) addr, (unsigned int) len);
goto buff_get_phys_error;
} else {
MM_INFO("O/P buffers:valid phy: %x sz: %x\n",
(unsigned int) addr, (unsigned int) len);
}
audio->phys = (int32_t)addr;
rc = ion_handle_get_flags(client, handle, &ionflag);
if (rc) {
MM_ERR("could not get flags for the handle\n");
goto buff_get_flags_error;
}
audio->map_v_read = ion_map_kernel(client, handle);
if (IS_ERR(audio->map_v_read)) {
MM_ERR("could not map write buffers\n");
rc = -ENOMEM;
goto buff_map_error;
}
audio->data = audio->map_v_read;
MM_DBG("write buf: phy addr 0x%08x kernel addr 0x%08x\n",
audio->phys, (int)audio->data);
MM_DBG("Memory addr = 0x%8x phy addr = 0x%8x\n",\
(int) audio->data, (int) audio->phys);
if ((file->f_mode & FMODE_WRITE) &&
(file->f_mode & FMODE_READ)) {
rc = -EACCES;
MM_ERR("Non tunnel encoding is not supported\n");
goto buff_map_error;
} else if (!(file->f_mode & FMODE_WRITE) &&
(file->f_mode & FMODE_READ)) {
audio->mode = MSM_AUD_ENC_MODE_TUNNEL;
MM_DBG("Opened for tunnel mode encoding\n");
} else {
rc = -EACCES;
goto buff_map_error;
}
/* Settings will be re-config at AUDIO_SET_CONFIG,
* but at least we need to have initial config
*/
audio->buffer_size = (FRAME_SIZE - 8);
audio->enc_type = ENC_TYPE_AMRNB | audio->mode;
audio->dtx_mode = -1;
audio->frame_format = 0;
audio->used_mode = 7; /* Bit Rate 12.2 kbps MR122 */
encid = audpreproc_aenc_alloc(audio->enc_type, &audio->module_name,
&audio->queue_ids);
if (encid < 0) {
MM_ERR("No free encoder available\n");
rc = -ENODEV;
goto aenc_alloc_error;
}
audio->enc_id = encid;
rc = msm_adsp_get(audio->module_name, &audio->audrec,
&audrec_amrnb_adsp_ops, audio);
if (rc) {
audpreproc_aenc_free(audio->enc_id);
goto aenc_alloc_error;
}
audio->stopped = 0;
audio->source = 0;
audamrnb_in_flush(audio);
audio->device_events = AUDDEV_EVT_DEV_RDY | AUDDEV_EVT_DEV_RLS |
AUDDEV_EVT_VOICE_STATE_CHG;
audio->voice_state = msm_get_voice_state();
rc = auddev_register_evt_listner(audio->device_events,
AUDDEV_CLNT_ENC, audio->enc_id,
amrnb_in_listener, (void *) audio);
if (rc) {
MM_ERR("failed to register device event listener\n");
goto evt_error;
}
audio->build_id = socinfo_get_build_id();
MM_DBG("Modem build id = %s\n", audio->build_id);
file->private_data = audio;
audio->opened = 1;
mutex_unlock(&audio->lock);
return rc;
evt_error:
msm_adsp_put(audio->audrec);
audpreproc_aenc_free(audio->enc_id);
ion_unmap_kernel(client, audio->buff_handle);
aenc_alloc_error:
buff_map_error:
buff_get_phys_error:
buff_get_flags_error:
ion_free(client, audio->buff_handle);
buff_alloc_error:
ion_client_destroy(client);
client_create_error:
done:
mutex_unlock(&audio->lock);
return rc;
}
static int __init voice_init(void)
{
int rc, i;
struct voice_data *v = &voice;
MM_INFO("\n"); /* Macro prints the file name and function */
mutex_init(&voice.voc_lock);
mutex_init(&voice.vol_lock);
v->handle = NULL;
v->cb_handle = NULL;
/* set default value */
v->default_mute_val = 1; /* default is mute */
v->default_vol_val = 0;
v->default_sample_val = 8000;
for (i = 0; i < VOC_RX_VOL_ARRAY_NUM; i++) {
v->max_rx_vol[i] = 0;
v->min_rx_vol[i] = 0;
}
v->network = NETWORK_GSM;
/* initialize dev_rx and dev_tx */
memset(&v->dev_tx, 0, sizeof(struct device_data));
memset(&v->dev_rx, 0, sizeof(struct device_data));
v->dev_rx.volume = v->default_vol_val;
v->dev_tx.mute = v->default_mute_val;
v->dev_state = DEV_INIT;
v->voc_state = VOICE_INIT;
atomic_set(&v->rel_start_flag, 0);
atomic_set(&v->acq_start_flag, 0);
v->dev_event = 0;
v->voc_event = 0;
init_completion(&voice.complete);
init_waitqueue_head(&v->dev_wait);
init_waitqueue_head(&v->voc_wait);
/* get device handle */
rc = daldevice_attach(VOICE_DALRPC_DEVICEID,
VOICE_DALRPC_PORT_NAME,
VOICE_DALRPC_CPU,
&v->handle);
if (rc) {
MM_ERR("Voc DALRPC call to Modem attach failed\n");
goto done;
}
/* Allocate the callback handle */
v->cb_handle = dalrpc_alloc_cb(v->handle, remote_cb_function, v);
if (v->cb_handle == NULL) {
MM_ERR("Allocate Callback failure\n");
goto err;
}
/* setup the callback */
rc = voice_cmd_init(v);
if (rc)
goto err1;
v->device_events = AUDDEV_EVT_DEV_CHG_VOICE |
AUDDEV_EVT_DEV_RDY |
AUDDEV_EVT_REL_PENDING |
AUDDEV_EVT_START_VOICE |
AUDDEV_EVT_END_VOICE |
AUDDEV_EVT_DEVICE_VOL_MUTE_CHG |
AUDDEV_EVT_FREQ_CHG | AUDDEV_EVT_AUDIO_LP_START | AUDDEV_EVT_AUDIO_LP_END;
MM_DBG(" to register call back \n");
/* register callback to auddev */
auddev_register_evt_listner(v->device_events, AUDDEV_CLNT_VOC,
0, voice_auddev_cb_function, v);
/* create and start thread */
v->task = kthread_run(voice_thread, v, "voice");
if (IS_ERR(v->task)) {
rc = PTR_ERR(v->task);
v->task = NULL;
} else
goto done;
err1: dalrpc_dealloc_cb(v->handle, v->cb_handle);
err:
daldevice_detach(v->handle);
v->handle = NULL;
done:
return rc;
}
static int audamrnb_in_open(struct inode *inode, struct file *file)
{
struct audio_in *audio = &the_audio_amrnb_in;
int rc;
int encid;
mutex_lock(&audio->lock);
if (audio->opened) {
rc = -EBUSY;
goto done;
}
audio->buffer_size = (FRAME_SIZE - 8);
audio->enc_type = ENC_TYPE_AMRNB;
audio->dtx_mode = -1;
audio->frame_format = 0;
audio->used_mode = 7;
encid = audpreproc_aenc_alloc(audio->enc_type, &audio->module_name,
&audio->queue_ids);
if (encid < 0) {
MM_ERR("No free encoder available\n");
rc = -ENODEV;
goto done;
}
audio->enc_id = encid;
rc = msm_adsp_get(audio->module_name, &audio->audrec,
&audrec_amrnb_adsp_ops, audio);
if (rc) {
audpreproc_aenc_free(audio->enc_id);
goto done;
}
audio->stopped = 0;
audio->source = 0;
audamrnb_in_flush(audio);
audio->device_events = AUDDEV_EVT_DEV_RDY | AUDDEV_EVT_DEV_RLS |
AUDDEV_EVT_VOICE_STATE_CHG;
audio->voice_state = msm_get_voice_state();
rc = auddev_register_evt_listner(audio->device_events,
AUDDEV_CLNT_ENC, audio->enc_id,
amrnb_in_listener, (void *) audio);
if (rc) {
MM_ERR("failed to register device event listener\n");
goto evt_error;
}
file->private_data = audio;
audio->opened = 1;
done:
mutex_unlock(&audio->lock);
return rc;
evt_error:
msm_adsp_put(audio->audrec);
audpreproc_aenc_free(audio->enc_id);
mutex_unlock(&audio->lock);
return rc;
}
static int audamrnb_in_open(struct inode *inode, struct file *file)
{
struct audio_in *audio = &the_audio_amrnb_in;
const char *modname;
int rc;
mutex_lock(&audio->lock);
if (atomic_read(&audio->opened) != 0) {
MM_AUD_ERR("Already open\n");
mutex_unlock(&audio->lock);
return -EBUSY;
}
if (!audio->phys) {
audio->phys = pmem_kalloc(DMASZ, PMEM_MEMTYPE_EBI1 | PMEM_ALIGNMENT_4K);
if (!IS_ERR((void *) audio->phys)) {
audio->data = ioremap(audio->phys, DMASZ);
if (!audio->data) {
MM_AUD_ERR("Could not remap DMA buffers\n");
pmem_kfree(audio->phys);
audio->phys = 0;
mutex_unlock(&audio->lock);
return -ENOMEM;
}
} else {
MM_AUD_ERR("Could not allocate DMA buffers\n");
audio->phys = 0;
mutex_unlock(&audio->lock);
return -ENOMEM;
}
}
audio->enc_id = audpreproc_aenc_alloc(ENC_TYPE_AMRNB | MSM_AUD_ENC_MODE_TUNNEL,
&modname, &audio->queue_ids);
if (audio->enc_id < 0) {
MM_ERR("No free encoder available\n");
mutex_unlock(&audio->lock);
return -ENODEV;
}
MM_DBG("allocated encoder %d, module %s\n", audio->enc_id, modname);
rc = auddev_register_evt_listner(AUDDEV_EVT_DEV_RDY | AUDDEV_EVT_DEV_RLS |
AUDDEV_EVT_VOICE_STATE_CHG,
AUDDEV_CLNT_ENC, audio->enc_id,
amrnb_in_listener, (void *) audio);
if (rc) {
MM_ERR("failed to register device event listener\n");
goto evt_error;
}
rc = msm_adsp_get(modname, &audio->audrec, &audrec_amrnb_adsp_ops, audio);
if (rc) {
MM_AUD_ERR("Failed to get AUDREC task\n");
goto no_audrec;
}
if(!audio->audrec) {
MM_AUD_ERR("Null AUDREC task returned by ADSP\n");
goto no_audrec;
}
audio->source = INTERNAL_CODEC_TX_SOURCE_MIX_MASK;
audio->buffer_size = (FRAME_SIZE - 8);
audio->enc_type = ENC_TYPE_AMRNB | MSM_AUD_ENC_MODE_TUNNEL;
audio->dtx_mode = AMRNB_DTX_MODE_ENABLE;
audio->used_mode = AMRNB_USED_MODE_MR122; /* Bit Rate 12.2 kbps */
audio->stopped = 0;
audio->running = 0;
audio->enabled = 0;
audamrnb_in_flush(audio);
audio->voice_state = msm_get_voice_state();
file->private_data = audio;
atomic_set(&audio->opened,1);
mutex_unlock(&audio->lock);
return rc;
no_audrec:
auddev_unregister_evt_listner(AUDDEV_CLNT_ENC, audio->enc_id);
evt_error:
audpreproc_aenc_free(audio->enc_id);
mutex_unlock(&audio->lock);
return rc;
}
static int audevrc_in_open(struct inode *inode, struct file *file)
{
struct audio_in *audio = &the_audio_evrc_in;
int rc;
int encid;
mutex_lock(&audio->lock);
if (audio->opened) {
rc = -EBUSY;
goto done;
}
/* Settings will be re-config at AUDIO_SET_CONFIG,
* but at least we need to have initial config
*/
audio->buffer_size = (FRAME_SIZE - 8);
audio->enc_type = ENC_TYPE_EVRC;
audio->cfg.cdma_rate = CDMA_RATE_FULL;
audio->cfg.min_bit_rate = CDMA_RATE_FULL;
audio->cfg.max_bit_rate = CDMA_RATE_FULL;
encid = audpreproc_aenc_alloc(audio->enc_type, &audio->module_name,
&audio->queue_ids);
if (encid < 0) {
MM_ERR("No free encoder available\n");
rc = -ENODEV;
goto done;
}
audio->enc_id = encid;
rc = msm_adsp_get(audio->module_name, &audio->audrec,
&audrec_evrc_adsp_ops, audio);
if (rc) {
audpreproc_aenc_free(audio->enc_id);
goto done;
}
audio->stopped = 0;
audio->source = 0;
audevrc_in_flush(audio);
audio->device_events = AUDDEV_EVT_DEV_RDY | AUDDEV_EVT_DEV_RLS |
AUDDEV_EVT_VOICE_STATE_CHG;
audio->voice_state = msm_get_voice_state();
rc = auddev_register_evt_listner(audio->device_events,
AUDDEV_CLNT_ENC, audio->enc_id,
evrc_in_listener, (void *) audio);
if (rc) {
MM_ERR("failed to register device event listener\n");
goto evt_error;
}
file->private_data = audio;
audio->opened = 1;
done:
mutex_unlock(&audio->lock);
return rc;
evt_error:
msm_adsp_put(audio->audrec);
audpreproc_aenc_free(audio->enc_id);
mutex_unlock(&audio->lock);
return rc;
}
static int audpcm_in_open(struct inode *inode, struct file *file)
{
struct audio_in *audio = &the_audio_in;
int rc;
int encid;
mutex_lock(&audio->lock);
if (audio->opened) {
rc = -EBUSY;
goto done;
}
/* Settings will be re-config at AUDIO_SET_CONFIG,
* but at least we need to have initial config
*/
audio->channel_mode = AUDREC_CMD_MODE_MONO;
audio->buffer_size = MONO_DATA_SIZE;
audio->samp_rate = 8000;
audio->enc_type = ENC_TYPE_WAV;
audio->source = INTERNAL_CODEC_TX_SOURCE_MIX_MASK;
encid = audpreproc_aenc_alloc(audio->enc_type, &audio->module_name,
&audio->queue_ids);
if (encid < 0) {
MM_ERR("No free encoder available\n");
rc = -ENODEV;
goto done;
}
audio->enc_id = encid;
rc = msm_adsp_get(audio->module_name, &audio->audrec,
&audrec_adsp_ops, audio);
if (rc) {
audpreproc_aenc_free(audio->enc_id);
goto done;
}
audio->stopped = 0;
audio->source = 0;
audio->abort = 0;
audpcm_in_flush(audio);
audio->device_events = AUDDEV_EVT_DEV_RDY | AUDDEV_EVT_DEV_RLS |
AUDDEV_EVT_FREQ_CHG;
rc = auddev_register_evt_listner(audio->device_events,
AUDDEV_CLNT_ENC, audio->enc_id,
pcm_in_listener, (void *) audio);
if (rc) {
MM_ERR("failed to register device event listener\n");
goto evt_error;
}
file->private_data = audio;
audio->opened = 1;
rc = 0;
done:
mutex_unlock(&audio->lock);
return rc;
evt_error:
msm_adsp_put(audio->audrec);
audpreproc_aenc_free(audio->enc_id);
mutex_unlock(&audio->lock);
return rc;
}
