static int vfe_7x_init(struct msm_vfe_resp *presp,
struct platform_device *dev)
{
int rc = 0;
init_waitqueue_head(&stopevent.wait);
stopevent.timeout = 200;
stopevent.state = 0;
if (presp && presp->vfe_resp)
resp = presp;
else{
CDBG_ERR("vfe_7k_init:fail here presp :0x%p presp->vfe_resp:0x%p\n",
presp,
presp->vfe_resp);
return -EFAULT;
}
/* Bring up all the required GPIOs and Clocks */
rc = msm_camio_enable(dev);
if (rc < 0){
CDBG_ERR("vfe_7k_init:msm_camio_enable fail\n");
return rc;
}
msm_camio_camif_pad_reg_reset();
extlen = sizeof(struct vfe_frame_extra);
extdata = kmalloc(extlen, GFP_ATOMIC);
if (!extdata) {
rc = -ENOMEM;
goto init_fail;
}
rc = msm_adsp_get("QCAMTASK", &qcam_mod, &vfe_7x_sync, NULL);
if (rc) {
rc = -EBUSY;
CDBG_ERR("vfe_7k_init:faile here %d\n",__LINE__);
goto get_qcam_fail;
}
rc = msm_adsp_get("VFETASK", &vfe_mod, &vfe_7x_sync, NULL);
if (rc) {
rc = -EBUSY;
CDBG_ERR("vfe_7k_init:faile here %d\n",__LINE__);
goto get_vfe_fail;
}
return 0;
get_vfe_fail:
msm_adsp_put(qcam_mod);
get_qcam_fail:
kfree(extdata);
init_fail:
extlen = 0;
return rc;
}
static int audio_in_open(struct inode *inode, struct file *file)
{
struct audio_in *audio = &the_audio_in;
int rc;
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->samp_rate = RPC_AUD_DEF_SAMPLE_RATE_11025;
audio->samp_rate_index = AUDREC_CMD_SAMP_RATE_INDX_11025;
audio->channel_mode = AUDREC_CMD_STEREO_MODE_MONO;
audio->buffer_size = MONO_DATA_SIZE;
audio->type = AUDREC_CMD_TYPE_0_INDEX_WAV;
/* For AAC, bit rate hard coded, default settings is
* sample rate (11025) x channel count (1) x recording quality (1.75)
* = 19293 bps */
audio->bit_rate = 19293;
audio->record_quality = 0x1c00;
rc = audmgr_open(&audio->audmgr);
if (rc)
goto done;
rc = msm_adsp_get("AUDPREPROCTASK", &audio->audpre,
&audpre_adsp_ops, audio);
if (rc)
goto done;
rc = msm_adsp_get("AUDRECTASK", &audio->audrec,
&audrec_adsp_ops, audio);
if (rc)
goto done;
audio->dsp_cnt = 0;
audio->stopped = 0;
audio->buffer_cfg_ioctl = 0; /* No valid ioctl set */
audio_flush(audio);
file->private_data = audio;
audio->opened = 1;
rc = 0;
done:
mutex_unlock(&audio->lock);
return rc;
}
int afe_config_fm_volume(uint16_t volume)
{
struct afe_cmd_fm_volume_config cmd;
struct msm_afe_state *afe = &the_afe_state;
int rc = 0;
MM_INFO(" configure fm volume\n");
mutex_lock(&afe->lock);
if (!afe->in_use) {
/* enable afe */
rc = msm_adsp_get("AFETASK", &afe->mod, &afe->adsp_ops, afe);
if (rc < 0) {
MM_ERR("%s: failed to get AFETASK module\n", __func__);
goto error_adsp_get;
}
rc = msm_adsp_enable(afe->mod);
if (rc < 0)
goto error_adsp_enable;
}
memset(&cmd, 0, sizeof(cmd));
cmd.cmd_id = AFE_CMD_FM_PLAYBACK_VOLUME_CMD;
cmd.volume = volume;
afe_send_queue(afe, &cmd, sizeof(cmd));
mutex_unlock(&afe->lock);
return rc;
error_adsp_enable:
msm_adsp_put(afe->mod);
afe->mod = NULL;
error_adsp_get:
mutex_unlock(&afe->lock);
return rc;
}
/*******************************************************************************
* Function Name : afe_config_loopback
* Args : enable or disable DSP loopback.
* dependencies : If QCOM changes ADSP firmware loopback command may not work.
*
********************************************************************************/
int afe_config_loopback(uint16_t enable)
{
struct afe_cmd_loopback_config cmd;
struct msm_afe_state *afe = &the_afe_state;
int rc = 0;
MM_INFO(" configure loopback %d\n",enable);
mutex_lock(&afe->lock);
if (!afe->in_use) {
/* enable afe */
rc = msm_adsp_get("AFETASK", &afe->mod, &afe->adsp_ops, afe);
if (rc < 0) {
MM_ERR("%s: failed to get AFETASK module\n", __func__);
goto error_adsp_get;
}
rc = msm_adsp_enable(afe->mod);
if (rc < 0)
goto error_adsp_enable;
}
memset(&cmd, 0, sizeof(cmd));
cmd.cmd_id = AFE_CMD_VOICE_LOOPBACK_CMD;
cmd.enable = enable;
afe_send_queue(afe, &cmd, sizeof(cmd));
mutex_unlock(&afe->lock);
return rc;
error_adsp_enable:
msm_adsp_put(afe->mod);
error_adsp_get:
mutex_unlock(&afe->lock);
return rc;
}
int afe_enable(u8 path_id, struct msm_afe_config *config)
{
struct msm_afe_state *afe = &the_afe_state;
int rc;
if (path_id < AFE_HW_PATH_CODEC_RX ||
path_id > AFE_HW_PATH_MI2S_TX) {
MM_AUD_ERR("invalid path id %d\n", path_id);
return -EINVAL;
}
MM_AUD_INFO("%s: path %d\n", __func__, path_id);
mutex_lock(&afe->lock);
if (!afe->in_use && !afe->aux_conf_flag) {
/* enable afe */
rc = msm_adsp_get("AFETASK", &afe->mod, &afe->adsp_ops, afe);
if (rc < 0) {
MM_AUD_ERR("%s: failed to get AFETASK module\n",
__func__);
goto error_adsp_get;
}
rc = msm_adsp_enable(afe->mod);
if (rc < 0)
goto error_adsp_enable;
}
/* Issue codec config command */
afe_dsp_codec_config(afe, path_id, 1, config);
rc = wait_event_timeout(afe->wait,
afe->codec_config[GETDEVICEID(path_id)],
msecs_to_jiffies(AFE_MAX_TIMEOUT));
if (!rc) {
MM_AUD_ERR("AFE failed to respond within %d ms\n",
AFE_MAX_TIMEOUT);
rc = -ENODEV;
if (!afe->in_use) {
if (!afe->aux_conf_flag ||
(afe->aux_conf_flag &&
(path_id == AFE_HW_PATH_AUXPCM_RX ||
path_id == AFE_HW_PATH_AUXPCM_TX))) {
/* clean up if there is no client */
msm_adsp_disable(afe->mod);
msm_adsp_put(afe->mod);
afe->aux_conf_flag = 0;
}
}
} else {
rc = 0;
afe->in_use++;
}
mutex_unlock(&afe->lock);
return rc;
error_adsp_enable:
msm_adsp_put(afe->mod);
error_adsp_get:
mutex_unlock(&afe->lock);
return rc;
}
/* must be called with audio->lock held */
static int audio_enable(struct audio *audio)
{
struct audmgr_config cfg;
int rc;
pr_info("audio_mp3_enable()\n");
if (audio->enabled)
return 0;
audio->out_tail = 0;
audio->out_needed = 0;
cfg.tx_rate = RPC_AUD_DEF_SAMPLE_RATE_NONE;
cfg.rx_rate = RPC_AUD_DEF_SAMPLE_RATE_48000;
cfg.def_method = RPC_AUD_DEF_METHOD_PLAYBACK;
cfg.codec = RPC_AUD_DEF_CODEC_MP3;
cfg.snd_method = RPC_SND_METHOD_MIDI;
audio_prevent_sleep(audio);
audio->audmgr.cb = audio_mp3_audmgr_cb;
rc = audmgr_enable(&audio->audmgr, &cfg);
if (rc < 0) {
pr_err("audio_mp3: audmgr_enable() failed\n");
audio_allow_sleep(audio);
return rc;
}
if (msm_adsp_get("AUDPLAY0TASK", &audio->audplay,
&audplay_adsp_ops, audio)) {
pr_err("audio_mp3: failed to get audplay0 dsp module\n");
goto err_get_adsp;
}
if (msm_adsp_enable(audio->audplay)) {
pr_err("audio_mp3: msm_adsp_enable(audplay) failed\n");
goto err_enable_adsp;
}
if (audpp_enable(audio->dec_id, audio_dsp_event,
audio_modem_event, audio)) {
pr_err("audio_mp3: audpp_enable() failed\n");
goto err_enable_audpp;
}
atomic_set(&audio->image_swap, 0);
audio->enabled = 1;
htc_pwrsink_audio_set(PWRSINK_AUDIO_MP3, 100);
return 0;
err_enable_audpp:
msm_adsp_disable(audio->audplay);
err_enable_adsp:
msm_adsp_put(audio->audplay);
err_get_adsp:
audmgr_disable(&audio->audmgr);
audio_allow_sleep(audio);
return -ENODEV;
}
static int audio_in_open(struct inode *inode, struct file *file)
{
struct audio_in *audio = &the_audio_in;
int rc;
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->samp_rate = RPC_AUD_DEF_SAMPLE_RATE_11025;
audio->samp_rate_index = AUDREC_CMD_SAMP_RATE_INDX_11025;
audio->channel_mode = AUDREC_CMD_STEREO_MODE_MONO;
audio->buffer_size = MONO_DATA_SIZE;
audio->type = AUDREC_CMD_TYPE_0_INDEX_WAV;
rc = audmgr_open(&audio->audmgr);
if (rc)
goto done;
rc = msm_adsp_get("AUDPREPROCTASK", &audio->audpre,
&audpre_adsp_ops, audio);
if (rc)
goto done;
rc = msm_adsp_get("AUDRECTASK", &audio->audrec,
&audrec_adsp_ops, audio);
if (rc)
goto done;
audio->audmgr.handle = 0xFFFF;
audio->dsp_cnt = 0;
audio->stopped = 0;
audio_flush(audio);
file->private_data = audio;
audio->opened = 1;
rc = 0;
done:
mutex_unlock(&audio->lock);
return rc;
}
int afe_config_rmc_block(struct acdb_rmc_block *acdb_rmc)
{
struct afe_cmd_cfg_rmc cmd;
struct msm_afe_state *afe = &the_afe_state;
int rc = 0;
int i = 0;
unsigned short *ptrmem = (unsigned short *)&cmd;
MM_DBG(" configure rmc block\n");
mutex_lock(&afe->lock);
if (!afe->in_use && !afe->mod) {
/* enable afe */
rc = msm_adsp_get("AFETASK", &afe->mod, &afe->adsp_ops, afe);
if (rc < 0) {
MM_DBG("%s: failed to get AFETASK module\n", __func__);
goto error_adsp_get;
}
rc = msm_adsp_enable(afe->mod);
if (rc < 0)
goto error_adsp_enable;
}
memset(&cmd, 0, sizeof(cmd));
cmd.cmd_id = AFE_CMD_CFG_RMC_PARAMS;
cmd.rmc_mode = acdb_rmc->rmc_enable;
cmd.rmc_ipw_length_ms = acdb_rmc->rmc_ipw_length_ms;
cmd.rmc_peak_length_ms = acdb_rmc->rmc_peak_length_ms;
cmd.rmc_init_pulse_length_ms = acdb_rmc->rmc_init_pulse_length_ms;
cmd.rmc_total_int_length_ms = acdb_rmc->rmc_total_int_length_ms;
cmd.rmc_rampupdn_length_ms = acdb_rmc->rmc_rampupdn_length_ms;
cmd.rmc_delay_length_ms = acdb_rmc->rmc_delay_length_ms;
cmd.rmc_detect_start_threshdb = acdb_rmc->rmc_detect_start_threshdb;
cmd.rmc_init_pulse_threshdb = acdb_rmc->rmc_init_pulse_threshdb;
for (i = 0; i < sizeof(cmd)/2; i++, ++ptrmem)
MM_DBG("cmd[%d]=0x%04x\n", i, *ptrmem);
afe_send_queue(afe, &cmd, sizeof(cmd));
mutex_unlock(&afe->lock);
return rc;
error_adsp_enable:
msm_adsp_put(afe->mod);
afe->mod = NULL;
error_adsp_get:
mutex_unlock(&afe->lock);
return rc;
}
int afe_config_aux_codec(int pcm_ctl_value, int aux_codec_intf_value,
int data_format_pad)
{
struct afe_cmd_aux_codec_config cmd;
struct msm_afe_state *afe = &the_afe_state;
int rc = 0;
MM_DBG(" configure aux codec \n");
mutex_lock(&afe->lock);
if (!afe->in_use && !afe->aux_conf_flag) {
/* enable afe */
rc = msm_adsp_get("AFETASK", &afe->mod, &afe->adsp_ops, afe);
if (rc < 0) {
MM_ERR("%s: failed to get AFETASK module\n", __func__);
goto error_adsp_get;
}
rc = msm_adsp_enable(afe->mod);
if (rc < 0)
goto error_adsp_enable;
}
afe->aux_conf_flag = 1;
memset(&cmd, 0, sizeof(cmd));
cmd.cmd_id = AFE_CMD_AUX_CODEC_CONFIG_CMD;
cmd.dma_path_ctl = 0;
cmd.pcm_ctl = pcm_ctl_value;
cmd.eight_khz_int_mode = 0;
cmd.aux_codec_intf_ctl = aux_codec_intf_value;
cmd.data_format_padding_info = data_format_pad;
afe_send_queue(afe, &cmd, sizeof(cmd));
mutex_unlock(&afe->lock);
return rc;
error_adsp_enable:
msm_adsp_put(afe->mod);
afe->mod = NULL;
error_adsp_get:
mutex_unlock(&afe->lock);
return rc;
}
int afe_config_fm_codec(int fm_enable, uint16_t source)
{
struct afe_cmd_fm_codec_config cmd;
struct msm_afe_state *afe = &the_afe_state;
int rc = 0;
int i = 0;
unsigned short *ptrmem = (unsigned short *)&cmd;
MM_INFO(" configure fm codec\n");
mutex_lock(&afe->lock);
if (!afe->in_use) {
/* enable afe */
rc = msm_adsp_get("AFETASK", &afe->mod, &afe->adsp_ops, afe);
if (rc < 0) {
MM_ERR("%s: failed to get AFETASK module\n", __func__);
goto error_adsp_get;
}
rc = msm_adsp_enable(afe->mod);
if (rc < 0)
goto error_adsp_enable;
}
memset(&cmd, 0, sizeof(cmd));
cmd.cmd_id = AFE_CMD_FM_RX_ROUTING_CMD;
cmd.enable = fm_enable;
cmd.device_id = source;
for (i = 0; i < sizeof(cmd)/2; i++, ++ptrmem)
MM_DBG("cmd[%d]=0x%04x\n", i, *ptrmem);
afe_send_queue(afe, &cmd, sizeof(cmd));
mutex_unlock(&afe->lock);
return rc;
error_adsp_enable:
msm_adsp_put(afe->mod);
afe->mod = NULL;
error_adsp_get:
mutex_unlock(&afe->lock);
return rc;
}
int afe_config_fm_calibration_gain(uint16_t device_id,
uint16_t calibration_gain)
{
struct afe_cmd_fm_calibgain_config cmd;
struct msm_afe_state *afe = &the_afe_state;
int rc = 0;
MM_INFO("Configure for rx device = 0x%4x, gain = 0x%4x\n", device_id,
calibration_gain);
mutex_lock(&afe->lock);
if (!afe->in_use) {
/* enable afe */
rc = msm_adsp_get("AFETASK", &afe->mod, &afe->adsp_ops, afe);
if (rc < 0) {
MM_ERR("%s: failed to get AFETASK module\n", __func__);
goto error_adsp_get;
}
rc = msm_adsp_enable(afe->mod);
if (rc < 0)
goto error_adsp_enable;
}
memset(&cmd, 0, sizeof(cmd));
cmd.cmd_id = AFE_CMD_FM_CALIBRATION_GAIN_CMD;
cmd.device_id = device_id;
cmd.calibration_gain = calibration_gain;
afe_send_queue(afe, &cmd, sizeof(cmd));
mutex_unlock(&afe->lock);
return rc;
error_adsp_enable:
msm_adsp_put(afe->mod);
afe->mod = NULL;
error_adsp_get:
mutex_unlock(&afe->lock);
return rc;
}
/*ADD 0010850: Ext Codec PCM Loopback support*/
int afe_config_ext_pcm_loopback(uint16_t enable)
{
struct afe_ext_loopback_cmd_cfg cmd;
struct msm_afe_state *afe = &the_afe_state;
int rc = 0;
MM_INFO(" configure ext pcm loopback %d\n",enable);
mutex_lock(&afe->lock);
if (!afe->in_use) {
/* enable afe */
rc = msm_adsp_get("AFETASK", &afe->mod, &afe->adsp_ops, afe);
if (rc < 0) {
MM_ERR("%s: failed to get AFETASK module\n", __func__);
goto error_adsp_get;
}
rc = msm_adsp_enable(afe->mod);
if (rc < 0)
goto error_adsp_enable;
}
memset(&cmd, 0, sizeof(cmd));
cmd.cmd_id = AFE_CMD_EXT_PCM_LOOPBACK_CMD;
cmd.en = enable;
cmd.src_id = QDSP5_DEVICE_AUX_CODEC_TX;
cmd.des_id = QDSP5_DEVICE_AUX_CODEC_RX;
cmd.reserved = 0;
afe_send_queue(afe, &cmd, sizeof(cmd));
mutex_unlock(&afe->lock);
return rc;
error_adsp_enable:
msm_adsp_put(afe->mod);
error_adsp_get:
mutex_unlock(&afe->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;
}
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_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 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 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;
}
/* 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->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;
audqcelp_in_flush(audio);
audio->device_events = AUDDEV_EVT_DEV_RDY | AUDDEV_EVT_DEV_RLS;
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 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 = msm_subsystem_map_buffer(
audio->phys, DMASZ,
MSM_SUBSYSTEM_MAP_KADDR, NULL, 0);
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->vaddr;
} 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 audpcm_in_open(struct inode *inode, struct file *file)
{
struct audio_in *audio = &the_audio_in;
int rc;
int len = 0;
unsigned long ionflag = 0;
ion_phys_addr_t addr = 0;
struct ion_handle *handle = NULL;
struct ion_client *client = NULL;
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->mode = MSM_AUD_ENC_MODE_TUNNEL;
audio->samp_rate = RPC_AUD_DEF_SAMPLE_RATE_11025;
audio->samp_rate_index = AUDREC_CMD_SAMP_RATE_INDX_11025;
audio->channel_mode = AUDREC_CMD_STEREO_MODE_MONO;
audio->buffer_size = MONO_DATA_SIZE;
audio->enc_type = AUDREC_CMD_TYPE_0_INDEX_WAV | audio->mode;
rc = audmgr_open(&audio->audmgr);
if (rc)
goto done;
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;
}
rc = msm_adsp_get("AUDPREPROCTASK", &audio->audpre,
&audpre_adsp_ops, audio);
if (rc) {
msm_adsp_put(audio->audrec);
audpreproc_aenc_free(audio->enc_id);
goto done;
}
audio->dsp_cnt = 0;
audio->stopped = 0;
audpcm_in_flush(audio);
client = msm_ion_client_create(UINT_MAX, "Audio_PCM_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;
MM_DBG("allocating mem sz = %d\n", DMASZ);
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 output_buff_alloc_error;
}
audio->output_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);
rc = -ENOMEM;
goto output_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");
rc = -ENOMEM;
goto output_buff_get_flags_error;
}
audio->data = ion_map_kernel(client, handle);
if (IS_ERR(audio->data)) {
MM_ERR("could not map read buffers,freeing instance 0x%08x\n",
(int)audio);
rc = -ENOMEM;
goto output_buff_map_error;
}
MM_DBG("read buf: phy addr 0x%08x kernel addr 0x%08x\n",
audio->phys, (int)audio->data);
file->private_data = audio;
audio->opened = 1;
rc = 0;
done:
mutex_unlock(&audio->lock);
return rc;
output_buff_map_error:
output_buff_get_phys_error:
output_buff_get_flags_error:
ion_free(client, audio->output_buff_handle);
output_buff_alloc_error:
ion_client_destroy(client);
client_create_error:
msm_adsp_put(audio->audrec);
msm_adsp_put(audio->audpre);
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 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 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 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 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;
}
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;
}
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;
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 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;
}
int audio_adsp_configure(struct msm_audio *prtd)
{
int ret, i;
if (prtd->dir == SNDRV_PCM_STREAM_PLAYBACK) {
prtd->data = prtd->playback_substream->dma_buffer.area;
prtd->phys = prtd->playback_substream->dma_buffer.addr;
}
if (prtd->dir == SNDRV_PCM_STREAM_CAPTURE) {
prtd->data = prtd->capture_substream->dma_buffer.area;
prtd->phys = prtd->capture_substream->dma_buffer.addr;
}
if (!prtd->data) {
ret = -ENOMEM;
goto err1;
}
ret = audmgr_open(&prtd->audmgr);
if (ret)
goto err2;
if (prtd->dir == SNDRV_PCM_STREAM_PLAYBACK) {
prtd->out_buffer_size = PLAYBACK_DMASZ;
prtd->out_sample_rate = 44100;
prtd->out_channel_mode = AUDPP_CMD_PCM_INTF_STEREO_V;
prtd->out_weight = 100;
prtd->out[0].data = prtd->data + 0;
prtd->out[0].addr = prtd->phys + 0;
prtd->out[0].size = BUFSZ;
prtd->out[1].data = prtd->data + BUFSZ;
prtd->out[1].addr = prtd->phys + BUFSZ;
prtd->out[1].size = BUFSZ;
}
if (prtd->dir == SNDRV_PCM_STREAM_CAPTURE) {
prtd->samp_rate = RPC_AUD_DEF_SAMPLE_RATE_44100;
prtd->samp_rate_index = AUDREC_CMD_SAMP_RATE_INDX_44100;
prtd->channel_mode = AUDREC_CMD_STEREO_MODE_STEREO;
prtd->buffer_size = STEREO_DATA_SIZE;
prtd->type = AUDREC_CMD_TYPE_0_INDEX_WAV;
prtd->tx_agc_cfg.cmd_id = AUDPREPROC_CMD_CFG_AGC_PARAMS;
prtd->ns_cfg.cmd_id = AUDPREPROC_CMD_CFG_NS_PARAMS;
prtd->iir_cfg.cmd_id =
AUDPREPROC_CMD_CFG_IIR_TUNING_FILTER_PARAMS;
ret = msm_adsp_get("AUDPREPROCTASK",
&prtd->audpre, &aud_pre_adsp_ops, prtd);
if (ret)
goto err3;
ret = msm_adsp_get("AUDRECTASK",
&prtd->audrec, &aud_rec_adsp_ops, prtd);
if (ret) {
msm_adsp_put(prtd->audpre);
goto err3;
}
prtd->dsp_cnt = 0;
prtd->in_head = 0;
prtd->in_tail = 0;
prtd->in_count = 0;
for (i = 0; i < FRAME_NUM; i++) {
prtd->in[i].size = 0;
prtd->in[i].read = 0;
}
}
return 0;
err3:
audmgr_close(&prtd->audmgr);
err2:
prtd->data = NULL;
err1:
return ret;
}
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;
}
static int audpcm_in_open(struct inode *inode, struct file *file)
{
struct audio_in *audio = &the_audio_in;
int rc;
int len = 0;
unsigned long ionflag = 0;
ion_phys_addr_t addr = 0;
struct ion_handle *handle = NULL;
struct ion_client *client = NULL;
int encid;
struct timespec ts;
struct rtc_time tm;
mutex_lock(&audio->lock);
if (audio->opened) {
rc = -EBUSY;
goto done;
}
audio->mode = MSM_AUD_ENC_MODE_TUNNEL;
audio->samp_rate = RPC_AUD_DEF_SAMPLE_RATE_11025;
audio->samp_rate_index = AUDREC_CMD_SAMP_RATE_INDX_11025;
audio->channel_mode = AUDREC_CMD_STEREO_MODE_MONO;
audio->buffer_size = MONO_DATA_SIZE;
audio->enc_type = AUDREC_CMD_TYPE_0_INDEX_WAV | audio->mode;
rc = audmgr_open(&audio->audmgr);
if (rc)
goto done;
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->dsp_cnt = 0;
audio->stopped = 0;
audpcm_in_flush(audio);
client = msm_ion_client_create(UINT_MAX, "Audio_PCM_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;
MM_DBG("allocating mem sz = %d\n", DMASZ);
handle = ion_alloc(client, DMASZ, SZ_4K,
ION_HEAP(ION_AUDIO_HEAP_ID));
if (IS_ERR_OR_NULL(handle)) {
MM_ERR("Unable to create allocate O/P buffers\n");
rc = -ENOMEM;
goto output_buff_alloc_error;
}
audio->output_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);
rc = -ENOMEM;
goto output_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");
rc = -ENOMEM;
goto output_buff_get_flags_error;
}
audio->data = ion_map_kernel(client, handle, ionflag);
if (IS_ERR(audio->data)) {
MM_ERR("could not map read buffers,freeing instance 0x%08x\n",
(int)audio);
rc = -ENOMEM;
goto output_buff_map_error;
}
MM_DBG("read buf: phy addr 0x%08x kernel addr 0x%08x\n",
audio->phys, (int)audio->data);
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;
output_buff_map_error:
output_buff_get_phys_error:
output_buff_get_flags_error:
ion_free(client, audio->output_buff_handle);
output_buff_alloc_error:
ion_client_destroy(client);
client_create_error:
msm_adsp_put(audio->audrec);
audpreproc_aenc_free(audio->enc_id);
mutex_unlock(&audio->lock);
return rc;
}
