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; }
static int msm_pcm_capture_close(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct msm_audio *prtd = runtime->private_data; alsa_audrec_disable(prtd); audmgr_close(&prtd->audmgr); msm_adsp_put(prtd->audrec); msm_adsp_put(prtd->audpre); kfree(prtd); return 0; }
static int audio_in_release(struct inode *inode, struct file *file) { struct audio_in *audio = file->private_data; mutex_lock(&audio->lock); audio_in_disable(audio); audio_flush(audio); msm_adsp_put(audio->audrec); msm_adsp_put(audio->audpre); audio->audrec = NULL; audio->audpre = NULL; audio->opened = 0; mutex_unlock(&audio->lock); return 0; }
int afe_disable(u8 path_id) { struct msm_afe_state *afe = &the_afe_state; int rc; mutex_lock(&afe->lock); BUG_ON(!afe->in_use); MM_DBG("%s() path_id:%d codec state:%d\n", __func__, path_id, afe->codec_config[GETDEVICEID(path_id)]); afe_dsp_codec_config(afe, path_id, 0, NULL); rc = wait_event_timeout(afe->wait, !afe->codec_config[GETDEVICEID(path_id)], msecs_to_jiffies(AFE_MAX_TIMEOUT)); if (!rc) { MM_ERR("AFE failed to respond within %d ms\n", AFE_MAX_TIMEOUT); rc = -1; } else rc = 0; afe->in_use--; MM_DBG("%s() in_use:%d \n", __func__, afe->in_use); if (!afe->in_use) { msm_adsp_disable(afe->mod); msm_adsp_put(afe->mod); afe->aux_conf_flag = 0; afe->mod = NULL; } mutex_unlock(&afe->lock); return rc; }
static void __exit afe_exit(void) { MM_AUD_INFO("AFE driver exit\n"); if (the_afe_state.mod) msm_adsp_put(the_afe_state.mod); return; }
static int auda2dp_in_release(struct inode *inode, struct file *file) { struct audio_a2dp_in *audio = file->private_data; mutex_lock(&audio->lock); /* with draw frequency for session incase not stopped the driver */ msm_snddev_withdraw_freq(audio->enc_id, SNDDEV_CAP_TX, AUDDEV_CLNT_ENC); auddev_unregister_evt_listner(AUDDEV_CLNT_ENC, audio->enc_id); /*reset the sampling frequency information at audpreproc layer*/ audio->session_info.sampling_freq = 0; audpreproc_update_audrec_info(&audio->session_info); auda2dp_in_disable(audio); auda2dp_in_flush(audio); msm_adsp_put(audio->audrec); audpreproc_aenc_free(audio->enc_id); audio->audrec = NULL; audio->opened = 0; if (audio->data) { msm_subsystem_unmap_buffer(audio->msm_map); free_contiguous_memory_by_paddr(audio->phys); audio->data = NULL; } mutex_unlock(&audio->lock); return 0; }
/******************************************************************************* * 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; }
static int audpcm_in_release(struct inode *inode, struct file *file) { struct audio_in *audio = file->private_data; if (!audio) return 0; mutex_lock(&audio->lock); audio->in_call = 0; msm_snddev_withdraw_freq(audio->enc_id, SNDDEV_CAP_TX, AUDDEV_CLNT_ENC); auddev_unregister_evt_listner(AUDDEV_CLNT_ENC, audio->enc_id); audpcm_in_disable(audio); audpcm_in_flush(audio); if (audio->audrec) msm_adsp_put(audio->audrec); if (audio->enc_id >=0) audpreproc_aenc_free(audio->enc_id); iounmap(audio->data); pmem_kfree(audio->phys); mutex_unlock(&audio->lock); kfree(audio); #ifdef TEST_ONLY current_audio_in = 0; #endif MM_DBG("closed.\n"); return 0; }
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; }
static int audpcm_in_release(struct inode *inode, struct file *file) { struct audio_in *audio = file->private_data; struct timespec ts; struct rtc_time tm; mutex_lock(&audio->lock); /* with draw frequency for session incase not stopped the driver */ msm_snddev_withdraw_freq(audio->enc_id, SNDDEV_CAP_TX, AUDDEV_CLNT_ENC); auddev_unregister_evt_listner(AUDDEV_CLNT_ENC, audio->enc_id); audpcm_in_disable(audio); audpcm_in_flush(audio); msm_adsp_put(audio->audrec); audpreproc_aenc_free(audio->enc_id); audio->audrec = NULL; audio->opened = 0; mutex_unlock(&audio->lock); getnstimeofday(&ts); rtc_time_to_tm(ts.tv_sec, &tm); pr_aud_info1("[ATS][stop_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 0; }
static int audpcm_in_release(struct inode *inode, struct file *file) { struct audio_in *audio = file->private_data; struct timespec ts; struct rtc_time tm; mutex_lock(&audio->lock); audpcm_in_disable(audio); audpcm_in_flush(audio); audpreproc_aenc_free(audio->enc_id); msm_adsp_put(audio->audrec); audio->audrec = NULL; audio->opened = 0; if (audio->data) { ion_unmap_kernel(audio->client, audio->output_buff_handle); ion_free(audio->client, audio->output_buff_handle); audio->data = NULL; } ion_client_destroy(audio->client); mutex_unlock(&audio->lock); getnstimeofday(&ts); rtc_time_to_tm(ts.tv_sec, &tm); pr_aud_info1("[ATS][stop_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 0; }
static int audamrnb_in_release(struct inode *inode, struct file *file) { struct audio_in *audio = file->private_data; MM_DBG("\n"); mutex_lock(&audio->lock); audio->in_call = 0; /* with draw frequency for session incase not stopped the driver */ msm_snddev_withdraw_freq(audio->enc_id, SNDDEV_CAP_TX, AUDDEV_CLNT_ENC); auddev_unregister_evt_listner(AUDDEV_CLNT_ENC, audio->enc_id); /*reset the sampling frequency information at audpreproc layer*/ audio->session_info.sampling_freq = 0; audpreproc_update_audrec_info(&audio->session_info); audamrnb_in_disable(audio); audamrnb_in_flush(audio); msm_adsp_put(audio->audrec); audpreproc_aenc_free(audio->enc_id); audio->audrec = NULL; audio->opened = 0; if (audio->data) { ion_unmap_kernel(audio->client, audio->buff_handle); ion_free(audio->client, audio->buff_handle); ion_client_destroy(audio->client); audio->data = NULL; } mutex_unlock(&audio->lock); return 0; }
static int audamrnb_in_release(struct inode *inode, struct file *file) { struct audio_in *audio = file->private_data; MM_DBG("\n"); mutex_lock(&audio->lock); audio->in_call = 0; /* with draw frequency for session incase not stopped the driver */ msm_snddev_withdraw_freq(audio->enc_id, SNDDEV_CAP_TX, AUDDEV_CLNT_ENC); auddev_unregister_evt_listner(AUDDEV_CLNT_ENC, audio->enc_id); audamrnb_in_disable(audio); audamrnb_in_flush(audio); msm_adsp_put(audio->audrec); audpreproc_aenc_free(audio->enc_id); audio->audrec = NULL; audio->opened = 0; if (audio->data) { iounmap(audio->data); pmem_kfree(audio->phys); audio->data = NULL; } mutex_unlock(&audio->lock); return 0; }
/* 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 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 void __exit afe_exit(void) { MM_INFO("AFE driver exit\n"); #ifdef CONFIG_DEBUG_FS if (debugfs_afelb) debugfs_remove(debugfs_afelb); #endif if (the_afe_state.mod) msm_adsp_put(the_afe_state.mod); return; }
static int audpcm_in_release(struct inode *inode, struct file *file) { struct audio_in *audio = file->private_data; mutex_lock(&audio->lock); audpcm_in_disable(audio); audpcm_in_flush(audio); audpreproc_aenc_free(audio->enc_id); msm_adsp_put(audio->audrec); msm_adsp_put(audio->audpre); audio->audrec = NULL; audio->audpre = NULL; audio->opened = 0; if (audio->data) { ion_unmap_kernel(audio->client, audio->output_buff_handle); ion_free(audio->client, audio->output_buff_handle); audio->data = NULL; } ion_client_destroy(audio->client); mutex_unlock(&audio->lock); return 0; }
static void vfe_7x_release(struct platform_device *dev) { mutex_lock(&vfe_lock); vfe_inuse = 0; vfe_syncdata = NULL; mutex_unlock(&vfe_lock); if (!vfestopped) { CDBG("%s:%d:Calling vfe_7x_stop()\n", __func__, __LINE__); vfe_7x_stop(); } else vfestopped = 0; msm_adsp_disable(qcam_mod); msm_adsp_disable(vfe_mod); msm_adsp_put(qcam_mod); msm_adsp_put(vfe_mod); msm_camio_disable(dev); kfree(extdata); extlen = 0; }
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; }
static int audqcelp_in_release(struct inode *inode, struct file *file) { struct audio_in *audio = file->private_data; MM_DBG("\n"); mutex_lock(&audio->lock); audio->in_call = 0; auddev_unregister_evt_listner(AUDDEV_CLNT_ENC, audio->enc_id); audqcelp_in_disable(audio); audqcelp_in_flush(audio); msm_adsp_put(audio->audrec); audpreproc_aenc_free(audio->enc_id); audio->audrec = NULL; audio->opened = 0; mutex_unlock(&audio->lock); return 0; }
static int audamrnb_in_release(struct inode *inode, struct file *file) { struct audio_in *audio = file->private_data; mutex_lock(&audio->lock); audio->in_call = 0; msm_snddev_withdraw_freq(audio->enc_id, SNDDEV_CAP_TX, AUDDEV_CLNT_ENC); auddev_unregister_evt_listner(AUDDEV_CLNT_ENC, audio->enc_id); audamrnb_in_disable(audio); audamrnb_in_flush(audio); msm_adsp_put(audio->audrec); audpreproc_aenc_free(audio->enc_id); atomic_set(&audio->opened,0); mutex_unlock(&audio->lock); MM_DBG("closed.\n"); return 0; }
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; }
/* must be called with audio->lock held */ static int audio_disable(struct audio *audio) { if (audio->enabled) { pr_info("audio_mp3_disable()\n"); audio->enabled = 0; auddec_dsp_config(audio, 0); wake_up(&audio->wait); audpp_disable(audio->dec_id, audio); msm_adsp_disable(audio->audplay); msm_adsp_put(audio->audplay); audmgr_disable(&audio->audmgr); atomic_set(&audio->image_swap, 0); audio->sent_bytes = 0; audio->consumed_bytes = 0; audio->total_consumed_bytes = 0; audio->out_needed = 0; audio->paused = 0; audio_allow_sleep(audio); htc_pwrsink_audio_set(PWRSINK_AUDIO_MP3, 0); } return 0; }
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 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; 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; }