static int mtk_pcm_i2s0_open(struct snd_pcm_substream *substream)
{
int ret = 0;
struct snd_pcm_runtime *runtime = substream->runtime;
AfeControlSramLock();
if (GetSramState() == SRAM_STATE_FREE)
{
mtk_i2s0_hardware.buffer_bytes_max = GetPLaybackSramFullSize();
mPlaybackSramState = SRAM_STATE_PLAYBACKFULL;
SetSramState(mPlaybackSramState);
}
else
{
mtk_i2s0_hardware.buffer_bytes_max = GetPLaybackSramPartial();
mPlaybackSramState = SRAM_STATE_PLAYBACKPARTIAL;
SetSramState(mPlaybackSramState);
}
AfeControlSramUnLock();
runtime->hw = mtk_i2s0_hardware;
printk("mtk_pcm_i2s0_open\n");
AudDrv_Clk_On();
memcpy((void *)(&(runtime->hw)), (void *)&mtk_i2s0_hardware , sizeof(struct snd_pcm_hardware));
pI2s0MemControl = Get_Mem_ControlT(Soc_Aud_Digital_Block_MEM_DL1);
ret = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
&constraints_sample_rates);
ret = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
if (ret < 0)
{
printk("snd_pcm_hw_constraint_integer failed\n");
}
//print for hw pcm information
printk("mtk_pcm_i2s0_open runtime rate = %d channels = %d substream->pcm->device = %d\n",
runtime->rate, runtime->channels, substream->pcm->device);
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
{
printk("SNDRV_PCM_STREAM_PLAYBACK mtkalsa_i2s0_playback_constraints\n");
}
else
{
}
if (ret < 0)
{
printk("mtk_pcm_i2s0_close\n");
mtk_pcm_i2s0_close(substream);
return ret;
}
printk("mtk_pcm_i2s0_open return\n");
AudDrv_Clk_Off();
return 0;
}
static int mtk_pcm_dl1_open(struct snd_pcm_substream *substream)
{
int ret = 0;
struct snd_pcm_runtime *runtime = substream->runtime;
PRINTK_AUDDRV("mtk_pcm_dl1_open\n");
AfeControlSramLock();
if (GetSramState() == SRAM_STATE_FREE)
{
mtk_pcm_dl1_hardware.buffer_bytes_max = GetPLaybackSramFullSize();
mPlaybackSramState = SRAM_STATE_PLAYBACKFULL;
SetSramState(mPlaybackSramState);
}
else
{
mtk_pcm_dl1_hardware.buffer_bytes_max = GetPLaybackDramSize();
mPlaybackSramState = SRAM_STATE_PLAYBACKDRAM;
}
AfeControlSramUnLock();
if (mPlaybackSramState == SRAM_STATE_PLAYBACKDRAM)
{
AudDrv_Emi_Clk_On();
}
printk("mtk_pcm_dl1_hardware.buffer_bytes_max = %zu mPlaybackSramState = %d\n", mtk_pcm_dl1_hardware.buffer_bytes_max, mPlaybackSramState);
runtime->hw = mtk_pcm_dl1_hardware;
AudDrv_ANA_Clk_On();
AudDrv_Clk_On();
memcpy((void *)(&(runtime->hw)), (void *)&mtk_pcm_dl1_hardware , sizeof(struct snd_pcm_hardware));
pMemControl = Get_Mem_ControlT(Soc_Aud_Digital_Block_MEM_DL1);
ret = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
&constraints_sample_rates);
if (ret < 0)
{
printk("snd_pcm_hw_constraint_integer failed\n");
}
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
{
printk("SNDRV_PCM_STREAM_PLAYBACK mtkalsa_dl1playback_constraints\n");
}
else
{
printk("SNDRV_PCM_STREAM_CAPTURE mtkalsa_dl1playback_constraints\n");
}
if (ret < 0)
{
printk("ret < 0 mtk_soc_pcm_dl1_close\n");
mtk_soc_pcm_dl1_close(substream);
return ret;
}
//PRINTK_AUDDRV("mtk_pcm_dl1_open return\n");
return 0;
}
static int mtk_capture_pcm_open(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
int ret = 0;
AudDrv_Clk_On();
AudDrv_ADC_Clk_On();
VUL_Control_context = Get_Mem_ControlT(Soc_Aud_Digital_Block_MEM_VUL);
// can allocate sram_dbg
AfeControlSramLock();
if (GetSramState() == SRAM_STATE_FREE )
{
printk("mtk_capture_pcm_open use sram \n");
mtk_capture_hardware.buffer_bytes_max = GetCaptureSramSize();
SetSramState(SRAM_STATE_CAPTURE);
mCaptureUseSram = true;
}
else
{
printk("mtk_capture_pcm_open use dram \n");
mtk_capture_hardware.buffer_bytes_max = UL1_MAX_BUFFER_SIZE;
}
AfeControlSramUnLock();
runtime->hw = mtk_capture_hardware;
memcpy((void *)(&(runtime->hw)), (void *)&mtk_capture_hardware , sizeof(struct snd_pcm_hardware));
ret = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
&constraints_sample_rates);
ret = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
if (ret < 0)
{
printk("snd_pcm_hw_constraint_integer failed\n");
}
if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
{
}
else
{
}
if (ret < 0)
{
printk("mtk_capture_pcm_close\n");
mtk_capture_pcm_close(substream);
return ret;
}
if(mCaptureUseSram == false)
{
AudDrv_Emi_Clk_On();
}
printk("mtk_capture_pcm_open return\n");
return 0;
}
static int mtk_dl1_awb_pcm_open(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
int ret = 0;
printk("mtk_dl1_awb_pcm_open\n");
Dl1_AWB_Control_context = Get_Mem_ControlT(Soc_Aud_Digital_Block_MEM_AWB);
runtime->hw = mtk_dl1_awb_hardware;
memcpy((void *)(&(runtime->hw)), (void *)&mtk_dl1_awb_hardware , sizeof(struct snd_pcm_hardware));
ret = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
&dl1_awb_constraints_sample_rates);
ret = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
if (ret < 0)
{
printk("snd_pcm_hw_constraint_integer failed\n");
}
// here open audio clocks
AudDrv_Clk_On();
//print for hw pcm information
printk("mtk_dl1_awb_pcm_open runtime rate = %d channels = %d \n", runtime->rate, runtime->channels);
runtime->hw.info |= SNDRV_PCM_INFO_INTERLEAVED;
runtime->hw.info |= SNDRV_PCM_INFO_NONINTERLEAVED;
runtime->hw.info |= SNDRV_PCM_INFO_MMAP_VALID;
if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
{
printk("SNDRV_PCM_STREAM_CAPTURE \n");
}
else
{
return -1;
}
if (ret < 0)
{
printk("mtk_dl1_awb_pcm_close\n");
mtk_dl1_awb_pcm_close(substream);
return ret;
}
AudDrv_Emi_Clk_On();
printk("mtk_dl1_awb_pcm_open return\n");
return 0;
}
static int mtk_pcm_fmtx_open(struct snd_pcm_substream *substream)
{
int ret = 0;
struct snd_pcm_runtime *runtime = substream->runtime;
PRINTK_AUD_FMTX("mtk_pcm_fmtx_open\n");
AudDrv_Clk_On();
// get dl1 memconptrol and record substream
pMemControl = Get_Mem_ControlT(Soc_Aud_Digital_Block_MEM_DL1);
runtime->hw = mtk_fmtx_hardware;
memcpy((void *)(&(runtime->hw)), (void *)&mtk_fmtx_hardware , sizeof(struct snd_pcm_hardware));
//PRINTK_AUDDRV("runtime->hw->rates= 0x%x mtk_pcm_hardware = = 0x%x\n ", runtime->hw.rates, &mtk_pcm_hardware);
ret = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
&constraints_fmtx_sample_rates);
ret = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
if (ret < 0)
{
PRINTK_AUD_FMTX("[mtk_pcm_fmtx_open]snd_pcm_hw_constraint_integer failed\n");
}
//print for hw pcm information
PRINTK_AUD_FMTX("[mtk_pcm_fmtx_open] runtime rate = %d channels = %d substream->pcm->device = %d\n",
runtime->rate, runtime->channels, substream->pcm->device);
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
{
PRINTK_AUD_FMTX("[mtk_pcm_fmtx_open]SNDRV_PCM_FMTX_PLAYBACK mtkalsa_playback_constraints\n");
}
else
{
}
if (ret < 0)
{
PRINTK_AUD_FMTX("[mtk_pcm_fmtx_open]mtk_pcm_fmtx_close\n");
mtk_pcm_fmtx_close(substream);
return ret;
}
//PRINTK_AUDDRV("mtk_pcm_open return\n");
return 0;
}
static int mtk_pcm_I2S0dl1_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *hw_params)
{
int ret = 0;
substream->runtime->dma_bytes = params_buffer_bytes(hw_params);
//printk("mtk_pcm_hw_params dma_bytes = %d\n",substream->runtime->dma_bytes);
#if 1
if (mPlaybackSramState == SRAM_STATE_PLAYBACKFULL)
{
//substream->runtime->dma_bytes = AFE_INTERNAL_SRAM_SIZE;
substream->runtime->dma_area = (unsigned char *)Get_Afe_SramBase_Pointer();
substream->runtime->dma_addr = AFE_INTERNAL_SRAM_PHY_BASE;
AudDrv_Allocate_DL1_Buffer(mDev, substream->runtime->dma_bytes);
}
else
{
substream->runtime->dma_bytes = params_buffer_bytes(hw_params);
substream->runtime->dma_area = Dl1_Playback_dma_buf->area;
substream->runtime->dma_addr = Dl1_Playback_dma_buf->addr;
SetDL1Buffer(substream, hw_params);
}
#else //old
// here to allcoate sram to hardware ---------------------------
AudDrv_Allocate_mem_Buffer(Soc_Aud_Digital_Block_MEM_DL1, substream->runtime->dma_bytes);
#ifdef AUDIO_MEMORY_SRAM
//substream->runtime->dma_bytes = AFE_INTERNAL_SRAM_SIZE;
substream->runtime->dma_area = (unsigned char *)Get_Afe_SramBase_Pointer();
substream->runtime->dma_addr = AFE_INTERNAL_SRAM_PHY_BASE;
#else
pI2S0dl1MemControl = Get_Mem_ControlT(Soc_Aud_Digital_Block_MEM_DL1);
Afe_Block = &pI2S0dl1MemControl->rBlock;;
substream->runtime->dma_area = (unsigned char *)Afe_Block->pucVirtBufAddr;
substream->runtime->dma_addr = Afe_Block->pucPhysBufAddr;
#endif
// -------------------------------------------------------
#endif
printk("1 dma_bytes = %zu dma_area = %p dma_addr = 0x%lx\n",
substream->runtime->dma_bytes, substream->runtime->dma_area, (long)substream->runtime->dma_addr);
return ret;
}
static int mtk_pcm_dl2_open(struct snd_pcm_substream *substream)
{
int ret = 0;
struct snd_pcm_runtime *runtime = substream->runtime;
PRINTK_AUDDRV("mtk_pcm_dl2_open\n");
mtk_pcm_dl2_hardware.buffer_bytes_max = GetPLaybackDramLowLatencySize();
mPlaybackSramState = SRAM_STATE_PLAYBACKDRAM;
mPlaybackUseSram = false;
if (mPlaybackSramState == SRAM_STATE_PLAYBACKDRAM)
AudDrv_Emi_Clk_On();
pr_warn("mtk_pcm_dl2_hardware.buffer_bytes_max = %zu mPlaybackSramState = %d\n",
mtk_pcm_dl2_hardware.buffer_bytes_max, mPlaybackSramState);
runtime->hw = mtk_pcm_dl2_hardware;
AudDrv_Clk_On();
memcpy((void *)(&(runtime->hw)), (void *)&mtk_pcm_dl2_hardware,
sizeof(struct snd_pcm_hardware));
pMemControl = Get_Mem_ControlT(Soc_Aud_Digital_Block_MEM_DL2);
ret = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
&constraints_sample_rates);
if (ret < 0)
pr_err("snd_pcm_hw_constraint_integer failed\n");
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
pr_warn("SNDRV_PCM_STREAM_PLAYBACK mtkalsa_dl2playback_constraints\n");
else
pr_warn("SNDRV_PCM_STREAM_CAPTURE mtkalsa_dl2playback_constraints\n");
if (ret < 0) {
pr_err("ret < 0 mtk_soc_pcm_dl2_close\n");
mtk_soc_pcm_dl2_close(substream);
return ret;
}
/* PRINTK_AUDDRV("mtk_pcm_dl2_open return\n"); */
return 0;
}
static int mtk_mrgrx_awb_pcm_open(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
int ret = 0;
printk("mtk_mrgrx_awb_pcm_open\n");
Mrgrx_AWB_Control_context = Get_Mem_ControlT(Soc_Aud_Digital_Block_MEM_AWB);
runtime->hw = mtk_mgrrx_awb_hardware;
memcpy((void *)(&(runtime->hw)), (void *)&mtk_mgrrx_awb_hardware , sizeof(struct snd_pcm_hardware));
ret = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
&mrgrx_awb_constraints_sample_rates);
ret = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
if (ret < 0)
{
printk("snd_pcm_hw_constraint_integer failed\n");
}
printk("mtk_mrgrx_awb_pcm_open runtime rate = %d channels = %d \n", runtime->rate, runtime->channels);
if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
{
printk("SNDRV_PCM_STREAM_CAPTURE \n");
}
else
{
return -1;
}
// here open audio clocks
AudDrv_Clk_On();
AudDrv_I2S_Clk_On();
if (ret < 0)
{
printk("mtk_mrgrx_awb_pcm_close\n");
mtk_mrgrx_awb_pcm_close(substream);
return ret;
}
printk("mtk_mrgrx_awb_pcm_open return\n");
return 0;
}
static int mtk_pcm_hdmi_open(struct snd_pcm_substream *substream)
{
int ret = 0;
struct snd_pcm_runtime *runtime = substream->runtime;
pr_debug("%s\n", __func__);
AudDrv_ANA_Clk_On();
AudDrv_Emi_Clk_On();
AudDrv_Clk_On();
runtime->hw = mtk_hdmi_hardware;
pMemControl = Get_Mem_ControlT(Soc_Aud_Digital_Block_MEM_HDMI);
memcpy((void *)(&(runtime->hw)), (void *)&mtk_hdmi_hardware,
sizeof(struct snd_pcm_hardware));
ret = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
&constraints_sample_rates);
if (ret < 0) {
PRINTK_AUD_HDMI("snd_pcm_hw_constraint_integer failed\n");
return ret;
}
/* print for hw pcm information */
pr_debug("%s, runtime->rate = %d, channels = %d, substream->pcm->device = %d\n",
__func__, runtime->rate, runtime->channels, substream->pcm->device);
runtime->hw.info |= SNDRV_PCM_INFO_INTERLEAVED;
runtime->hw.info |= SNDRV_PCM_INFO_NONINTERLEAVED;
runtime->hw.info |= SNDRV_PCM_INFO_MMAP_VALID;
PRINTK_AUD_HDMI("mtk_pcm_hdmi_open return\n");
return 0;
}
static int mtk_bt_dai_pcm_open(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
int ret = 0;
pr_warn("mtk_bt_dai_pcm_open\n");
Bt_Dai_Control_context = Get_Mem_ControlT(Soc_Aud_Digital_Block_MEM_DAI);
runtime->hw = mtk_btdai_hardware;
memcpy((void *)(&(runtime->hw)), (void *)&mtk_btdai_hardware , sizeof(struct snd_pcm_hardware));
ret = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
&bt_dai_constraints_sample_rates);
ret = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
if (ret < 0)
pr_err("snd_pcm_hw_constraint_integer failed\n");
AudDrv_Clk_On();
/* print for hw pcm information */
pr_warn("mtk_bt_dai_pcm_open runtime rate = %d channels = %d\n", runtime->rate, runtime->channels);
runtime->hw.info |= SNDRV_PCM_INFO_INTERLEAVED;
runtime->hw.info |= SNDRV_PCM_INFO_NONINTERLEAVED;
if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
pr_warn("SNDRV_PCM_STREAM_CAPTURE\n");
else
return -1;
if (ret < 0) {
pr_err("mtk_bt_dai_pcm_close\n");
mtk_bt_dai_pcm_close(substream);
return ret;
}
pr_warn("mtk_bt_dai_pcm_open return\n");
return 0;
}
