/* must be called with audio->lock held */
static int audio_enable(struct audio *audio)
{
pr_info("audio_enable\n");
if (audio->enabled)
return 0;
/* refuse to start if we're not ready */
if (!audio->out[0].used || !audio->out[1].used)
return -EIO;
/* we start buffers 0 and 1, so buffer 0 will be the
* next one the dsp will want
*/
audio->out_tail = 0;
audio->out_needed = 0;
audio_prevent_sleep(audio);
if (audpp_enable(-1, audio_dsp_event, audio)) {
MM_ERR("audpp_enable() failed\n");
audio_allow_sleep(audio);
return -ENODEV;
}
audio->enabled = 1;
htc_pwrsink_set(PWRSINK_AUDIO, 100);
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;
}
/* must be called with audio->lock held */
static int audio_enable(struct audio *audio)
{
struct audmgr_config cfg;
int rc;
MM_INFO("[CLK]\n"); /* Macro prints the file name and function */
if (audio->enabled)
return 0;
/* refuse to start if we're not ready */
if (!audio->out[0].used || !audio->out[1].used)
return -EIO;
/* we start buffers 0 and 1, so buffer 0 will be the
* next one the dsp will want
*/
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_HOST_PCM;
cfg.codec = RPC_AUD_DEF_CODEC_PCM;
cfg.snd_method = RPC_SND_METHOD_MIDI;
audio_prevent_sleep(audio);
rc = audmgr_enable(&audio->audmgr, &cfg);
if (rc < 0) {
audio_allow_sleep(audio);
return rc;
}
#ifdef CONFIG_CCI_SPEAKER
/*cci.johnny_lee, for pop-noise issue */
MM_INFO("[CLK] speaker_audmgr_enable(true)\n");
if (speaker_audmgr_enable(true) < 0)
{
MM_ERR("[CLK] speaker_audmgr_enable return failed, we will retry after 600ms\n");
}
else
{
msleep(80);
}
#endif
if (audpp_enable(-1, audio_dsp_event, audio)) {
MM_ERR("audpp_enable() failed\n");
audmgr_disable(&audio->audmgr);
audio_allow_sleep(audio);
return -ENODEV;
}
audio->enabled = 1;
htc_pwrsink_set(PWRSINK_AUDIO, 100);
return 0;
}
/* must be called with audio->lock held */
static int audio_enable(struct audio *audio)
{
struct audmgr_config cfg;
int rc;
MM_INFO("\n"); /* Macro prints the file name and function */
if (audio->enabled)
return 0;
/* refuse to start if we're not ready */
if (!audio->out[0].used || !audio->out[1].used)
return -EIO;
/* we start buffers 0 and 1, so buffer 0 will be the
* next one the dsp will want
*/
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_HOST_PCM;
cfg.codec = RPC_AUD_DEF_CODEC_PCM;
cfg.snd_method = RPC_SND_METHOD_MIDI;
audio_prevent_sleep(audio);
rc = audmgr_enable(&audio->audmgr, &cfg);
if (rc < 0) {
audio_allow_sleep(audio);
return rc;
}
#ifdef CONFIG_AMP_MAX97000
if(!audio_enabled)
{
audio_enabled = 1;
//max97000_resume();
}
#endif
if (audpp_enable(-1, audio_dsp_event, audio)) {
MM_ERR("audpp_enable() failed\n");
audmgr_disable(&audio->audmgr);
audio_allow_sleep(audio);
return -ENODEV;
}
audio->enabled = 1;
htc_pwrsink_set(PWRSINK_AUDIO, 100);
return 0;
}
static int msm8k_pcm_open(struct inode *inode, struct file *f)
{
struct pcm *pcm;
struct cad_open_struct_type cos;
int rc;
D("%s\n", __func__);
mutex_lock(&pcm_lock);
if (pcm_opened) {
pr_err("pcm: busy\n");
rc = -EBUSY;
goto done;
}
pcm = kmalloc(sizeof(struct pcm), GFP_KERNEL);
if (pcm == NULL) {
pr_err("Could not allocate memory for pcm driver\n");
return CAD_RES_FAILURE;
}
f->private_data = pcm;
memset(pcm, 0, sizeof(struct pcm));
pcm->cfg.buffer_size = 4096;
pcm->cfg.buffer_count = 2;
pcm->cfg.channel_count = 1;
pcm->cfg.sample_rate = 48000;
audio_prevent_sleep();
cos.format = CAD_FORMAT_PCM;
cos.op_code = CAD_OPEN_OP_WRITE;
pcm->cad_w_handle = cad_open(&cos);
if (pcm->cad_w_handle == 0) {
audio_allow_sleep();
rc = CAD_RES_FAILURE;
} else {
pcm_opened = 1;
rc = CAD_RES_SUCCESS;
}
done:
mutex_unlock(&pcm_lock);
return rc;
}
/* must be called with audio->lock held */
static int audio_enable(struct audio *audio)
{
struct audmgr_config cfg;
int rc;
pr_info("audio_enable()\n");
if (audio->enabled)
return 0;
/* refuse to start if we're not ready */
if (!audio->out[0].used || !audio->out[1].used)
return -EIO;
/* we start buffers 0 and 1, so buffer 0 will be the
* next one the dsp will want
*/
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_HOST_PCM;
cfg.codec = RPC_AUD_DEF_CODEC_PCM;
cfg.snd_method = RPC_SND_METHOD_MIDI;
audio_prevent_sleep(audio);
rc = audmgr_enable(&audio->audmgr, &cfg);
if (rc < 0) {
audio_allow_sleep(audio);
return rc;
}
if (audpp_enable(-1, audio_dsp_event, audio)) {
pr_err("audio: audpp_enable() failed\n");
audmgr_disable(&audio->audmgr);
audio_allow_sleep(audio);
return -ENODEV;
}
audio->enabled = 1;
htc_pwrsink_set(PWRSINK_AUDIO, 100);
return 0;
}
struct audio_client *q6audio_open_pcm(uint32_t bufsz, uint32_t rate,
uint32_t channels, uint32_t flags, uint32_t acdb_id)
{
int rc, retry = 5;
struct audio_client *ac;
if (q6audio_init())
return 0;
ac = audio_client_alloc(bufsz);
if (!ac)
return 0;
ac->flags = flags;
mutex_lock(&audio_path_lock);
if (ac->flags & AUDIO_FLAG_WRITE) {
audio_rx_path_refcount++;
if (audio_rx_path_refcount == 1) {
_audio_rx_clk_enable();
#ifdef CONFIG_MSM_QDSP6_CALLREC
q6_rx_path_enable(0, acdb_id);
adie_rx_path_enable(acdb_id);
#else
audio_update_acdb(audio_rx_device_id, acdb_id);
qdsp6_devchg_notify(ac_control, ADSP_AUDIO_RX_DEVICE, audio_rx_device_id);
qdsp6_standby(ac_control);
qdsp6_start(ac_control);
#endif
}
} else {
/* TODO: consider concurrency with voice call */
#ifdef CONFIG_MSM_QDSP6_CALLREC
if (audio_tx_path_refcount > 0) {
tx_clk_freq = 8000;
} else {
tx_clk_freq = rate;
}
#else
tx_clk_freq = rate;
#endif
audio_tx_path_refcount++;
if (audio_tx_path_refcount == 1) {
#ifdef CONFIG_MSM_QDSP6_CALLREC
tx_clk_freq = rate;
#endif
_audio_tx_clk_enable();
_audio_tx_path_enable(0, acdb_id);
}
}
for (retry = 5;; retry--) {
if (ac->flags & AUDIO_FLAG_WRITE)
rc = audio_out_open(ac, bufsz, rate, channels);
else
#ifdef CONFIG_MSM_QDSP6_CALLREC
rc = audio_in_open(ac, bufsz, flags, rate, channels);
#else
rc = audio_in_open(ac, bufsz, rate, channels);
#endif
if (rc == 0)
break;
if (retry == 0)
q6audio_dsp_not_responding();
pr_err("q6audio: open pcm error %d, retrying\n", rc);
msleep(1);
}
if (ac->flags & AUDIO_FLAG_WRITE) {
if (audio_rx_path_refcount == 1) {
#ifndef CONFIG_MSM_QDSP6_CALLREC
adie_enable();
adie_set_path(adie, audio_rx_path_id, ADIE_PATH_RX);
adie_set_path_freq_plan(adie, ADIE_PATH_RX, 48000);
adie_proceed_to_stage(adie, ADIE_PATH_RX, ADIE_STAGE_DIGITAL_READY);
adie_proceed_to_stage(adie, ADIE_PATH_RX, ADIE_STAGE_DIGITAL_ANALOG_READY);
#endif
audio_rx_analog_enable(1);
}
}
mutex_unlock(&audio_path_lock);
for (retry = 5;; retry--) {
rc = audio_command(ac, ADSP_AUDIO_IOCTL_CMD_SESSION_START);
if (rc == 0)
break;
if (retry == 0)
q6audio_dsp_not_responding();
pr_err("q6audio: stream start error %d, retrying\n", rc);
}
if (!(ac->flags & AUDIO_FLAG_WRITE)) {
ac->buf[0].used = 1;
ac->buf[1].used = 1;
q6audio_read(ac, &ac->buf[0]);
q6audio_read(ac, &ac->buf[1]);
}
audio_prevent_sleep();
return ac;
}
