void AudDrv_APLL24M_Clk_Off(void)
{
pr_debug("+%s %d \n", __func__, Aud_APLL24M_Clk_cntr);
mutex_lock(&auddrv_pmic_mutex);
Aud_APLL24M_Clk_cntr--;
if (Aud_APLL24M_Clk_cntr == 0)
{
PRINTK_AUDDRV("+%s disable_clock ADC clk(%x)\n", __func__, Aud_APLL24M_Clk_cntr);
#ifdef PM_MANAGER_API
#if defined(CONFIG_MTK_LEGACY)
if (disable_clock(MT_CG_AUDIO_24M, "AUDIO"))
{
PRINTK_AUD_CLK("%s fail", __func__);
}
if (disable_clock(MT_CG_AUDIO_APLL2_TUNER, "AUDIO"))
{
PRINTK_AUD_CLK("%s fail", __func__);
}
#else
if (paudclk->aud_apll24m_clk_status)
{
clk_disable_unprepare(paudclk->aud_apll24m_clk);
}
if (paudclk->aud_apll2_tuner_clk_status)
{
clk_disable_unprepare(paudclk->aud_apll2_tuner_clk);
}
#endif
clkmux_sel(MT_MUX_AUD1, 0, "AUDIO"); //select 26M
disable_mux(MT_MUX_AUD1, "AUDIO");
#endif
}
if (Aud_APLL24M_Clk_cntr < 0)
{
PRINTK_AUDDRV("%s <0 (%d) \n", __func__, Aud_APLL24M_Clk_cntr);
Aud_APLL24M_Clk_cntr = 0;
}
mutex_unlock(&auddrv_pmic_mutex);
}
static snd_pcm_uframes_t mtk_pcm_i2s0_pointer(struct snd_pcm_substream *substream)
{
kal_int32 HW_memory_index = 0;
kal_int32 HW_Cur_ReadIdx = 0;
kal_uint32 Frameidx = 0;
kal_int32 Afe_consumed_bytes = 0;
AFE_BLOCK_T *Afe_Block = &pI2s0MemControl->rBlock;
//struct snd_pcm_runtime *runtime = substream->runtime;
PRINTK_AUD_DL1(" %s Afe_Block->u4DMAReadIdx = 0x%x\n", __func__, Afe_Block->u4DMAReadIdx);
Auddrv_Dl1_Spinlock_lock();
// get total bytes to copy
//Frameidx = audio_bytes_to_frame(substream , Afe_Block->u4DMAReadIdx);
//return Frameidx;
if (GetMemoryPathEnable(Soc_Aud_Digital_Block_MEM_DL1) == true)
{
HW_Cur_ReadIdx = Afe_Get_Reg(AFE_DL1_CUR);
if (HW_Cur_ReadIdx == 0)
{
PRINTK_AUDDRV("[Auddrv] HW_Cur_ReadIdx ==0 \n");
HW_Cur_ReadIdx = Afe_Block->pucPhysBufAddr;
}
HW_memory_index = (HW_Cur_ReadIdx - Afe_Block->pucPhysBufAddr);
if (HW_memory_index >= Afe_Block->u4DMAReadIdx)
{
Afe_consumed_bytes = HW_memory_index - Afe_Block->u4DMAReadIdx;
}
else
{
Afe_consumed_bytes = Afe_Block->u4BufferSize + HW_memory_index - Afe_Block->u4DMAReadIdx ;
}
Afe_consumed_bytes = Align64ByteSize(Afe_consumed_bytes);
Afe_Block->u4DataRemained -= Afe_consumed_bytes;
Afe_Block->u4DMAReadIdx += Afe_consumed_bytes;
Afe_Block->u4DMAReadIdx %= Afe_Block->u4BufferSize;
PRINTK_AUD_DL1("[Auddrv] HW_Cur_ReadIdx =0x%x HW_memory_index = 0x%x Afe_consumed_bytes = 0x%x\n", HW_Cur_ReadIdx, HW_memory_index, Afe_consumed_bytes);
Auddrv_Dl1_Spinlock_unlock();
return audio_bytes_to_frame(substream , Afe_Block->u4DMAReadIdx);
}
else
{
Frameidx = audio_bytes_to_frame(substream , Afe_Block->u4DMAReadIdx);
Auddrv_Dl1_Spinlock_unlock();
return Frameidx;
}
}
static snd_pcm_uframes_t mtk_dl1bt_pcm_pointer(struct snd_pcm_substream
*substream)
{
kal_int32 HW_memory_index = 0;
kal_int32 HW_Cur_ReadIdx = 0;
kal_uint32 Frameidx = 0;
kal_int32 Afe_consumed_bytes = 0;
unsigned long flags;
AFE_BLOCK_T *Afe_Block = &pdl1btMemControl->rBlock;
/* struct snd_pcm_runtime *runtime = substream->runtime; */
PRINTK_AUD_DL1(" %s Afe_Block->u4DMAReadIdx = 0x%x\n", __func__, Afe_Block->u4DMAReadIdx);
spin_lock_irqsave(&pdl1btMemControl->substream_lock, flags);
/* get total bytes to copy */
/* Frameidx = audio_bytes_to_frame(substream , Afe_Block->u4DMAReadIdx); */
/* return Frameidx; */
if (GetMemoryPathEnable(Soc_Aud_Digital_Block_MEM_DL1) == true) {
HW_Cur_ReadIdx = Afe_Get_Reg(AFE_DL1_CUR);
if (HW_Cur_ReadIdx == 0) {
PRINTK_AUDDRV("[Auddrv] HW_Cur_ReadIdx ==0\n");
HW_Cur_ReadIdx = Afe_Block->pucPhysBufAddr;
}
HW_memory_index = (HW_Cur_ReadIdx - Afe_Block->pucPhysBufAddr);
if (HW_memory_index >= Afe_Block->u4DMAReadIdx)
Afe_consumed_bytes = HW_memory_index - Afe_Block->u4DMAReadIdx;
else
Afe_consumed_bytes = Afe_Block->u4BufferSize + HW_memory_index -
Afe_Block->u4DMAReadIdx;
#ifdef AUDIO_64BYTE_ALIGN
Afe_consumed_bytes = Align64ByteSize(Afe_consumed_bytes);
#endif
Afe_Block->u4DataRemained -= Afe_consumed_bytes;
Afe_Block->u4DMAReadIdx += Afe_consumed_bytes;
Afe_Block->u4DMAReadIdx %= Afe_Block->u4BufferSize;
PRINTK_AUD_DL1
("[Auddrv] HW_Cur_ReadIdx =0x%x HW_memory_index = 0x%x Afe_consumed_bytes = 0x%x\n",
HW_Cur_ReadIdx, HW_memory_index, Afe_consumed_bytes);
spin_unlock_irqrestore(&pdl1btMemControl->substream_lock, flags);
return audio_bytes_to_frame(substream, Afe_Block->u4DMAReadIdx);
} else {
Frameidx = audio_bytes_to_frame(substream, Afe_Block->u4DMAReadIdx);
spin_unlock_irqrestore(&pdl1btMemControl->substream_lock, flags);
return Frameidx;
}
}
static int mtk_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
{
PRINTK_AUDDRV("mtk_pcm_trigger cmd = %d\n", cmd);
switch (cmd) {
case SNDRV_PCM_TRIGGER_START:
case SNDRV_PCM_TRIGGER_RESUME:
return mtk_pcm_dl1bt_start(substream);
case SNDRV_PCM_TRIGGER_STOP:
case SNDRV_PCM_TRIGGER_SUSPEND:
return mtk_pcm_dl1Bt_stop(substream);
}
return -EINVAL;
}
void AudDrv_ADC_Clk_On(void)
{
//PRINTK_AUDDRV("+AudDrv_ADC_Clk_On, Aud_ADC_Clk_cntr:%d \n", Aud_ADC_Clk_cntr);
mutex_lock(&auddrv_pmic_mutex);
if (Aud_ADC_Clk_cntr == 0)
{
PRINTK_AUDDRV("+AudDrv_ADC_Clk_On enable_clock ADC clk(%x)\n", Aud_ADC_Clk_cntr);
Afe_Set_Reg(AUDIO_TOP_CON0, 0 << 24 , 1 << 24);
}
Aud_ADC_Clk_cntr++;
mutex_unlock(&auddrv_pmic_mutex);
}
static int mtk_pcm_i2s0_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *hw_params)
{
int ret = 0;
PRINTK_AUDDRV("mtk_pcm_hw_params \n");
/* runtime->dma_bytes has to be set manually to allow mmap */
substream->runtime->dma_bytes = params_buffer_bytes(hw_params);
// here to allcoate sram to hardware ---------------------------
AudDrv_Allocate_mem_Buffer(mDev, Soc_Aud_Digital_Block_MEM_DL1, substream->runtime->dma_bytes);
//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;
// -------------------------------------------------------
PRINTK_AUDDRV("1 dma_bytes = %d dma_area = %p dma_addr = 0x%x\n",
substream->runtime->dma_bytes, substream->runtime->dma_area, (unsigned int)substream->runtime->dma_addr);
return ret;
}
static snd_pcm_uframes_t mtk_pcm_dl2_pointer(struct snd_pcm_substream *substream)
{
kal_int32 HW_memory_index = 0;
kal_int32 HW_Cur_ReadIdx = 0;
kal_uint32 Frameidx = 0;
kal_int32 Afe_consumed_bytes = 0;
AFE_BLOCK_T *Afe_Block = &pMemControl->rBlock;
/* struct snd_pcm_runtime *runtime = substream->runtime; */
PRINTK_AUD_DL2(" %s Afe_Block->u4DMAReadIdx = 0x%x\n", __func__, Afe_Block->u4DMAReadIdx);
Auddrv_Dl2_Spinlock_lock();
/* get total bytes to copy */
/* Frameidx = audio_bytes_to_frame(substream , Afe_Block->u4DMAReadIdx); */
/* return Frameidx; */
if (GetMemoryPathEnable(Soc_Aud_Digital_Block_MEM_DL2) == true) {
HW_Cur_ReadIdx = Afe_Get_Reg(AFE_DL2_CUR);
if (HW_Cur_ReadIdx == 0) {
PRINTK_AUDDRV("[Auddrv] HW_Cur_ReadIdx ==0\n");
HW_Cur_ReadIdx = Afe_Block->pucPhysBufAddr;
}
HW_memory_index = (HW_Cur_ReadIdx - Afe_Block->pucPhysBufAddr);
if (HW_memory_index >= Afe_Block->u4DMAReadIdx) {
Afe_consumed_bytes = HW_memory_index - Afe_Block->u4DMAReadIdx;
} else {
Afe_consumed_bytes = Afe_Block->u4BufferSize + HW_memory_index -
Afe_Block->u4DMAReadIdx;
}
#ifdef AUDIO_64BYTE_ALIGN /* no need to do 64byte align */
Afe_consumed_bytes = Align64ByteSize(Afe_consumed_bytes);
#endif
Afe_Block->u4DataRemained -= Afe_consumed_bytes;
Afe_Block->u4DMAReadIdx += Afe_consumed_bytes;
Afe_Block->u4DMAReadIdx %= Afe_Block->u4BufferSize;
PRINTK_AUD_DL2
("[Auddrv] HW_Cur_ReadIdx =0x%x HW_memory_index = 0x%x Afe_consumed_bytes = 0x%x\n",
HW_Cur_ReadIdx, HW_memory_index, Afe_consumed_bytes);
Auddrv_Dl2_Spinlock_unlock();
Frameidx = audio_bytes_to_frame(substream, Afe_Block->u4DMAReadIdx);
} else {
Frameidx = audio_bytes_to_frame(substream, Afe_Block->u4DMAReadIdx);
Auddrv_Dl2_Spinlock_unlock();
}
return Frameidx;
}
void AudDrv_ADC_Clk_On(void)
{
//PRINTK_AUDDRV("+AudDrv_ADC_Clk_On, Aud_ADC_Clk_cntr:%d \n", Aud_ADC_Clk_cntr);
mutex_lock(&auddrv_pmic_mutex);
if (Aud_ADC_Clk_cntr == 0)
{
PRINTK_AUDDRV("+AudDrv_ADC_Clk_On enable_clock ADC clk(%x)\n", Aud_ADC_Clk_cntr);
#ifdef PM_MANAGER_API
//hwPowerOn(MT65XX_POWER_LDO_VA28,VOL_2800 , "AUDIO");
#endif
}
Aud_ADC_Clk_cntr++;
mutex_unlock(&auddrv_pmic_mutex);
}
void AudDrv_ADC_Clk_On(void)
{
//PRINTK_AUDDRV("+AudDrv_ADC_Clk_On, Aud_ADC_Clk_cntr:%d \n", Aud_ADC_Clk_cntr);
#if !defined(CONFIG_MTK_LEGACY)
int ret = 0;
#endif
mutex_lock(&auddrv_pmic_mutex);
if (Aud_ADC_Clk_cntr == 0)
{
PRINTK_AUDDRV("+AudDrv_ADC_Clk_On enable_clock ADC clk(%x)\n", Aud_ADC_Clk_cntr);
// Afe_Set_Reg(AUDIO_TOP_CON0, 0 << 24 , 1 << 24);
#ifdef PM_MANAGER_API
#if defined(CONFIG_MTK_LEGACY)
if (enable_clock(MT_CG_AUDIO_ADC, "AUDIO"))
{
PRINTK_AUD_CLK("%s fail", __func__);
}
#else
if (paudclk->aud_adc_clk_status)
{
ret = clk_prepare_enable(paudclk->aud_adc_clk);
if (!ret)
{
pr_err("%s Aud enable_clock enable_clock ADC fail", __func__);
BUG();
return;
}
}
else
{
pr_err("%s clk_status error Aud enable_clock ADC fail", __func__);
BUG();
return;
}
#endif
#else
Afe_Set_Reg(AUDIO_TOP_CON0, 0 << 24 , 1 << 24);
#endif
}
Aud_ADC_Clk_cntr++;
mutex_unlock(&auddrv_pmic_mutex);
}
static int __init mtk_soc_dl1bt_platform_init(void)
{
int ret;
PRINTK_AUDDRV("%s\n", __func__);
#ifndef CONFIG_OF
soc_mtk_dl1bt_dev = platform_device_alloc(MT_SOC_VOIP_BT_OUT, -1);
if (!soc_mtk_dl1bt_dev)
return -ENOMEM;
ret = platform_device_add(soc_mtk_dl1bt_dev);
if (ret != 0) {
platform_device_put(soc_mtk_dl1bt_dev);
return ret;
}
#endif
ret = platform_driver_register(&mtk_dl1bt_driver);
return ret;
}
static int mtk_dl1bt_pcm_open(struct snd_pcm_substream *substream)
{
int ret = 0;
struct snd_pcm_runtime *runtime = substream->runtime;
AfeControlSramLock();
if (GetSramState() == SRAM_STATE_FREE) {
mtk_dl1bt_pcm_hardware.buffer_bytes_max = GetPLaybackSramFullSize();
mPlaybackSramState = SRAM_STATE_PLAYBACKFULL;
SetSramState(mPlaybackSramState);
} else {
mtk_dl1bt_pcm_hardware.buffer_bytes_max = GetPLaybackSramPartial();
mPlaybackSramState = SRAM_STATE_PLAYBACKPARTIAL;
SetSramState(mPlaybackSramState);
}
AfeControlSramUnLock();
PRINTK_AUDDRV("mtk_dl1bt_pcm_open\n");
AudDrv_Clk_On();
/* get dl1 memconptrol and record substream */
pdl1btMemControl = Get_Mem_ControlT(Soc_Aud_Digital_Block_MEM_DL1);
runtime->hw = mtk_dl1bt_pcm_hardware;
memcpy((void *)(&(runtime->hw)), (void *)&mtk_dl1bt_pcm_hardware,
sizeof(struct snd_pcm_hardware));
ret = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
&constraints_dl1_sample_rates);
if (ret < 0)
PRINTK_AUDDRV("snd_pcm_hw_constraint_list failed\n");
ret = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
if (ret < 0)
PRINTK_AUDDRV("snd_pcm_hw_constraint_integer failed\n");
/* print for hw pcm information */
PRINTK_AUDDRV
("mtk_dl1bt_pcm_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_AUDDRV("SNDRV_PCM_STREAM_PLAYBACK mtkalsa_playback_constraints\n");
if (ret < 0) {
PRINTK_AUDDRV("mtk_Dl1Bt_close\n");
mtk_Dl1Bt_close(substream);
return ret;
}
return 0;
}
static int mtk_soc_dl2_probe(struct platform_device *pdev)
{
PRINTK_AUDDRV("%s\n", __func__);
pdev->dev.coherent_dma_mask = DMA_BIT_MASK(64);
if (!pdev->dev.dma_mask)
pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
if (pdev->dev.of_node) {
dev_set_name(&pdev->dev, "%s", MT_SOC_DL2_PCM);
} else {
pr_err("%s invalid of_node\n", __func__);
return -ENODEV;
}
pr_warn("%s: dev name %s\n", __func__, dev_name(&pdev->dev));
return snd_soc_register_platform(&pdev->dev, &mtk_soc_platform);
}
void AudDrv_ADC3_Clk_On(void)
{
PRINTK_AUD_CLK("+%s %d \n", __func__, Aud_ADC3_Clk_cntr);
mutex_lock(&auddrv_pmic_mutex);
if (Aud_ADC3_Clk_cntr == 0)
{
PRINTK_AUDDRV("+%s enable_clock ADC clk(%x)\n", __func__, Aud_ADC3_Clk_cntr);
#if 0 //K2 removed
#ifdef PM_MANAGER_API
if (enable_clock(MT_CG_AUDIO_ADDA3, "AUDIO"))
{
PRINTK_AUD_CLK("%s fail", __func__);
}
#endif
#endif
}
Aud_ADC2_Clk_cntr++;
mutex_unlock(&auddrv_pmic_mutex);
}
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 snd_pcm_uframes_t mtk_pcm_pointer(struct snd_pcm_substream *substream)
{
kal_int32 HW_memory_index = 0;
kal_int32 HW_Cur_ReadIdx = 0;
kal_uint32 Frameidx = 0;
kal_int32 Afe_consumed_bytes = 0;
AFE_BLOCK_T *Afe_Block = &pMemControl->rBlock;
unsigned int flags;
struct snd_pcm_runtime *runtime = substream->runtime;
PRINTK_AUD_DL1(" %s Afe_Block->u4DMAReadIdx = 0x%x\n", __func__, Afe_Block->u4DMAReadIdx);
// get total bytes to copy
//Frameidx = audio_bytes_to_frame(substream , Afe_Block->u4DMAReadIdx);
//return Frameidx;
spin_lock_irqsave(&auddrv_DLCtl_lock, flags);
if (GetMemoryPathEnable(Soc_Aud_Digital_Block_MEM_DL1) == true)
{
HW_Cur_ReadIdx = Afe_Get_Reg(AFE_DL1_CUR);
if (HW_Cur_ReadIdx == 0)
{
PRINTK_AUDDRV("[Auddrv] HW_Cur_ReadIdx ==0 \n");
HW_Cur_ReadIdx = Afe_Block->pucPhysBufAddr;
}
HW_memory_index = (HW_Cur_ReadIdx - Afe_Block->pucPhysBufAddr);
if (HW_memory_index > Afe_Block->u4DMAReadIdx)
{
Afe_consumed_bytes = HW_memory_index - Afe_Block->u4DMAReadIdx;
}
else
{
Afe_consumed_bytes = Afe_Block->u4BufferSize + HW_memory_index - Afe_Block->u4DMAReadIdx ;
}
Afe_Block->u4DataRemained -= Afe_consumed_bytes;
Afe_Block->u4DMAReadIdx += Afe_consumed_bytes;
Afe_Block->u4DMAReadIdx %= Afe_Block->u4BufferSize;
PRINTK_AUD_DL1("[Auddrv] HW_Cur_ReadIdx =0x%x HW_memory_index = 0x%x pointer return = 0x%x \n", HW_Cur_ReadIdx, HW_memory_index, (HW_memory_index >> 2));
spin_unlock_irqrestore(&auddrv_DLCtl_lock, flags);
return audio_bytes_to_frame(substream , Afe_Block->u4DMAReadIdx);
}
void AudDrv_ADC2_Clk_On(void)
{
PRINTK_AUD_CLK("+%s %d \n", __func__, Aud_ADC2_Clk_cntr);
mutex_lock(&auddrv_pmic_mutex);
if (Aud_ADC2_Clk_cntr == 0)
{
PRINTK_AUDDRV("+%s enable_clock ADC clk(%x)\n", __func__, Aud_ADC2_Clk_cntr);
#if 0 //K2 removed
#ifdef PM_MANAGER_API
if (enable_clock(MT_CG_AUDIO_ADDA2, "AUDIO"))
{
PRINTK_AUD_CLK("%s fail", __func__);
}
#else
Afe_Set_Reg(AUDIO_TOP_CON0, 0 << 23 , 1 << 23); //temp hard code setting, after confirm with enable clock usage, this could be removed.
#endif
#endif
}
Aud_ADC2_Clk_cntr++;
mutex_unlock(&auddrv_pmic_mutex);
}
void AudDrv_APLL24M_Clk_On(void)
{
PRINTK_AUD_CLK("+%s %d \n", __func__, Aud_APLL24M_Clk_cntr);
mutex_lock(&auddrv_pmic_mutex);
if (Aud_APLL24M_Clk_cntr == 0)
{
PRINTK_AUDDRV("+%s enable_clock ADC clk(%x)\n", __func__, Aud_APLL24M_Clk_cntr);
#ifdef PM_MANAGER_API
enable_mux(MT_MUX_AUD2, "AUDIO");
clkmux_sel(MT_MUX_AUD2, 1, "AUDIO"); //APLL2
if (enable_clock(MT_CG_AUDIO_24M, "AUDIO"))
{
PRINTK_AUD_CLK("%s fail", __func__);
}
if (enable_clock(MT_CG_AUDIO_APLL2_TUNER, "AUDIO"))
{
PRINTK_AUD_CLK("%s fail", __func__);
}
#endif
}
Aud_APLL24M_Clk_cntr++;
mutex_unlock(&auddrv_pmic_mutex);
}
static int mtk_pcm_dl2_copy(struct snd_pcm_substream *substream,
int channel, snd_pcm_uframes_t pos,
void __user *dst, snd_pcm_uframes_t count)
{
AFE_BLOCK_T *Afe_Block = NULL;
int copy_size = 0, Afe_WriteIdx_tmp;
unsigned long flags;
/* struct snd_pcm_runtime *runtime = substream->runtime; */
char *data_w_ptr = (char *)dst;
PRINTK_AUD_DL2("mtk_pcm_copy pos = %lu count = %lu\n ", pos, count);
/* get total bytes to copy */
count = audio_frame_to_bytes(substream, count);
/* check which memif nned to be write */
Afe_Block = &pMemControl->rBlock;
PRINTK_AUD_DL2("AudDrv_write WriteIdx=0x%x, ReadIdx=0x%x, DataRemained=0x%x\n",
Afe_Block->u4WriteIdx, Afe_Block->u4DMAReadIdx, Afe_Block->u4DataRemained);
if (Afe_Block->u4BufferSize == 0) {
pr_err("AudDrv_write: u4BufferSize=0 Error");
return 0;
}
AudDrv_checkDLISRStatus();
spin_lock_irqsave(&auddrv_DL2Ctl_lock, flags);
copy_size = Afe_Block->u4BufferSize - Afe_Block->u4DataRemained; /* free space of the buffer */
spin_unlock_irqrestore(&auddrv_DL2Ctl_lock, flags);
if (count <= copy_size) {
if (copy_size < 0)
copy_size = 0;
else
copy_size = count;
}
#ifdef AUDIO_64BYTE_ALIGN /* no need to do 64byte align */
copy_size = Align64ByteSize(copy_size);
#endif
PRINTK_AUD_DL2("copy_size=0x%x, count=0x%x\n", copy_size, (unsigned int)count);
if (copy_size != 0) {
spin_lock_irqsave(&auddrv_DL2Ctl_lock, flags);
Afe_WriteIdx_tmp = Afe_Block->u4WriteIdx;
spin_unlock_irqrestore(&auddrv_DL2Ctl_lock, flags);
if (Afe_WriteIdx_tmp + copy_size < Afe_Block->u4BufferSize) { /* copy once */
if (!access_ok(VERIFY_READ, data_w_ptr, copy_size)) {
PRINTK_AUDDRV("AudDrv_write 0ptr invalid data_w_ptr=%p, size=%d",
data_w_ptr, copy_size);
PRINTK_AUDDRV("AudDrv_write u4BufferSize=%d, u4DataRemained=%d",
Afe_Block->u4BufferSize, Afe_Block->u4DataRemained);
} else {
PRINTK_AUD_DL2
("memcpy VirtBufAddr+Afe_WriteIdx= %p,data_w_ptr = %p copy_size = 0x%x\n",
Afe_Block->pucVirtBufAddr + Afe_WriteIdx_tmp, data_w_ptr,
copy_size);
if (copy_from_user
((Afe_Block->pucVirtBufAddr + Afe_WriteIdx_tmp), data_w_ptr,
copy_size)) {
PRINTK_AUDDRV("AudDrv_write Fail copy from user\n");
return -1;
}
}
spin_lock_irqsave(&auddrv_DL2Ctl_lock, flags);
Afe_Block->u4DataRemained += copy_size;
Afe_Block->u4WriteIdx = Afe_WriteIdx_tmp + copy_size;
Afe_Block->u4WriteIdx %= Afe_Block->u4BufferSize;
spin_unlock_irqrestore(&auddrv_DL2Ctl_lock, flags);
data_w_ptr += copy_size;
count -= copy_size;
PRINTK_AUD_DL2
("AudDrv_write finish1, copy:%x, WriteIdx:%x,ReadIdx=%x,Remained:%x, count=%d \r\n",
copy_size, Afe_Block->u4WriteIdx, Afe_Block->u4DMAReadIdx,
Afe_Block->u4DataRemained, (int)count);
} else { /* copy twice */
kal_uint32 size_1 = 0, size_2 = 0;
#ifdef AUDIO_64BYTE_ALIGN /* no need to do 64byte align */
size_1 = Align64ByteSize((Afe_Block->u4BufferSize - Afe_WriteIdx_tmp));
size_2 = Align64ByteSize((copy_size - size_1));
#else
size_1 = Afe_Block->u4BufferSize - Afe_WriteIdx_tmp;
size_2 = copy_size - size_1;
#endif
PRINTK_AUD_DL2("size_1=0x%x, size_2=0x%x\n", size_1, size_2);
if (!access_ok(VERIFY_READ, data_w_ptr, size_1)) {
pr_err("AudDrv_write 1ptr invalid data_w_ptr=%p, size_1=%d",
data_w_ptr, size_1);
pr_err("AudDrv_write u4BufferSize=%d, u4DataRemained=%d",
Afe_Block->u4BufferSize, Afe_Block->u4DataRemained);
} else {
PRINTK_AUD_DL2
("mcmcpy Afe_Block->pucVirtBufAddr+Afe_WriteIdx= %p data_w_ptr = %p size_1 = %x\n",
Afe_Block->pucVirtBufAddr + Afe_WriteIdx_tmp, data_w_ptr,
size_1);
if ((copy_from_user
((Afe_Block->pucVirtBufAddr + Afe_WriteIdx_tmp), data_w_ptr,
(unsigned int)size_1))) {
PRINTK_AUDDRV("AudDrv_write Fail 1 copy from user");
return -1;
}
}
spin_lock_irqsave(&auddrv_DL2Ctl_lock, flags);
Afe_Block->u4DataRemained += size_1;
Afe_Block->u4WriteIdx = Afe_WriteIdx_tmp + size_1;
Afe_Block->u4WriteIdx %= Afe_Block->u4BufferSize;
Afe_WriteIdx_tmp = Afe_Block->u4WriteIdx;
spin_unlock_irqrestore(&auddrv_DL2Ctl_lock, flags);
if (!access_ok(VERIFY_READ, data_w_ptr + size_1, size_2)) {
PRINTK_AUDDRV
("AudDrv_write 2ptr invalid data_w_ptr=%p, size_1=%d, size_2=%d",
data_w_ptr, size_1, size_2);
PRINTK_AUDDRV("AudDrv_write u4BufferSize=%d, u4DataRemained=%d",
Afe_Block->u4BufferSize, Afe_Block->u4DataRemained);
} else {
PRINTK_AUD_DL2
("mcmcpy VirtBufAddr+Afe_WriteIdx= %p,data_w_ptr+size_1 = %p size_2 = %x\n",
Afe_Block->pucVirtBufAddr + Afe_WriteIdx_tmp,
data_w_ptr + size_1, (unsigned int)size_2);
if ((copy_from_user
((Afe_Block->pucVirtBufAddr + Afe_WriteIdx_tmp),
(data_w_ptr + size_1), size_2))) {
PRINTK_AUDDRV("AudDrv_write Fail 2 copy from user");
return -1;
}
}
spin_lock_irqsave(&auddrv_DL2Ctl_lock, flags);
Afe_Block->u4DataRemained += size_2;
Afe_Block->u4WriteIdx = Afe_WriteIdx_tmp + size_2;
Afe_Block->u4WriteIdx %= Afe_Block->u4BufferSize;
spin_unlock_irqrestore(&auddrv_DL2Ctl_lock, flags);
count -= copy_size;
data_w_ptr += copy_size;
PRINTK_AUD_DL2
("AudDrv_write finish2, copy size:%x, WriteIdx:%x,ReadIdx=%x DataRemained:%x \r\n",
copy_size, Afe_Block->u4WriteIdx, Afe_Block->u4DMAReadIdx,
Afe_Block->u4DataRemained);
}
}
return 0;
}
static int mtk_pcm_dl1bt_hw_free(struct snd_pcm_substream *substream)
{
PRINTK_AUDDRV("mtk_pcm_dl1bt_hw_free\n");
return 0;
}
static int mtk_asoc_dl1bt_probe(struct snd_soc_platform *platform)
{
PRINTK_AUDDRV("mtk_asoc_dl1bt_probe\n");
return 0;
}
static void __exit mtk_dl2_soc_platform_exit(void)
{
PRINTK_AUDDRV("%s\n", __func__);
platform_driver_unregister(&mtk_dl2_driver);
}
static struct page *mtk_pcm_dl2_page(struct snd_pcm_substream *substream, unsigned long offset)
{
PRINTK_AUDDRV("%s\n", __func__);
return virt_to_page(dummy_page[substream->stream]); /* the same page */
}
static int mtk_pcm_dl2_silence(struct snd_pcm_substream *substream,
int channel, snd_pcm_uframes_t pos, snd_pcm_uframes_t count)
{
PRINTK_AUDDRV("%s\n", __func__);
return 0; /* do nothing */
}
static int mtk_asoc_Dl1Bt_pcm_new(struct snd_soc_pcm_runtime *rtd)
{
int ret = 0;
PRINTK_AUDDRV("%s\n", __func__);
return ret;
}
void AudDrv_APLL24M_Clk_On(void)
{
pr_debug("+%s %d \n", __func__, Aud_APLL24M_Clk_cntr);
#if !defined(CONFIG_MTK_LEGACY)
int ret = 0;
#endif
mutex_lock(&auddrv_pmic_mutex);
if (Aud_APLL24M_Clk_cntr == 0)
{
PRINTK_AUDDRV("+%s enable_clock ADC clk(%x)\n", __func__, Aud_APLL24M_Clk_cntr);
#ifdef PM_MANAGER_API
enable_mux(MT_MUX_AUD1, "AUDIO");
clkmux_sel(MT_MUX_AUD1, 1, "AUDIO"); //hf_faud_1_ck apll1_ck
pll_fsel(APLL1, 0xbc7ea932); //ALPP1 98.304M
#if defined(CONFIG_MTK_LEGACY)
if (enable_clock(MT_CG_AUDIO_24M, "AUDIO"))
{
PRINTK_AUD_CLK("%s fail", __func__);
}
if (enable_clock(MT_CG_AUDIO_APLL2_TUNER, "AUDIO"))
{
PRINTK_AUD_CLK("%s fail", __func__);
}
#else
if (paudclk->aud_apll24m_clk_status)
{
ret = clk_prepare_enable(paudclk->aud_apll24m_clk);
if (!ret)
{
pr_err("%s Aud enable_clock enable_clock aud_apll24m_clk fail", __func__);
BUG();
return;
}
}
else
{
pr_err("%s clk_status error Aud enable_clock aud_apll24m_clk fail", __func__);
BUG();
return;
}
if (paudclk->aud_apll2_tuner_clk_status)
{
ret = clk_prepare_enable(paudclk->aud_apll2_tuner_clk);
if (!ret)
{
pr_err("%s Aud enable_clock enable_clock aud_apll2_tuner_clk fail", __func__);
BUG();
return;
}
}
else
{
pr_err("%s clk_status error Aud enable_clock aud_apll2_tuner_clk fail", __func__);
BUG();
return;
}
#endif
#endif
}
Aud_APLL24M_Clk_cntr++;
mutex_unlock(&auddrv_pmic_mutex);
}
static int mtk_uldlloopback_pcm_hw_free(struct snd_pcm_substream *substream)
{
PRINTK_AUDDRV("mtk_uldlloopback_pcm_hw_free \n");
return snd_pcm_lib_free_pages(substream);
}
static int mtk_pcm_dl1bt_copy(struct snd_pcm_substream *substream,
int channel, snd_pcm_uframes_t pos,
void __user *dst, snd_pcm_uframes_t count)
{
AFE_BLOCK_T *Afe_Block = NULL;
unsigned long flags;
char *data_w_ptr = (char *)dst;
int copy_size = 0, Afe_WriteIdx_tmp;
PRINTK_AUD_DL1("mtk_pcm_dl1bt_copy pos = %lu count = %lu\n ", pos, count);
/* get total bytes to copy */
count = audio_frame_to_bytes(substream, count);
/* check which memif nned to be write */
Afe_Block = &pdl1btMemControl->rBlock;
/* handle for buffer management */
PRINTK_AUD_DL1("AudDrv_write WriteIdx=0x%x, ReadIdx=0x%x, DataRemained=0x%x\n",
Afe_Block->u4WriteIdx, Afe_Block->u4DMAReadIdx, Afe_Block->u4DataRemained);
if (Afe_Block->u4BufferSize == 0) {
pr_err("AudDrv_write: u4BufferSize=0 Error");
return 0;
}
spin_lock_irqsave(&auddrv_DL1BTCtl_lock, flags);
copy_size = Afe_Block->u4BufferSize - Afe_Block->u4DataRemained; /* free space of the buffer */
spin_unlock_irqrestore(&auddrv_DL1BTCtl_lock, flags);
if (count <= copy_size) {
if (copy_size < 0)
copy_size = 0;
else
copy_size = count;
}
#ifdef AUDIO_64BYTE_ALIGN
copy_size = Align64ByteSize(copy_size);
#endif
PRINTK_AUD_DL1("copy_size=0x%x, count=0x%x\n", copy_size, (unsigned int)count);
if (copy_size != 0) {
spin_lock_irqsave(&auddrv_DL1BTCtl_lock, flags);
Afe_WriteIdx_tmp = Afe_Block->u4WriteIdx;
spin_unlock_irqrestore(&auddrv_DL1BTCtl_lock, flags);
if (Afe_WriteIdx_tmp + copy_size < Afe_Block->u4BufferSize) { /* copy once */
if (!access_ok(VERIFY_READ, data_w_ptr, copy_size)) {
PRINTK_AUDDRV("AudDrv_write 0ptr invalid data_w_ptr=%p, size=%d",
data_w_ptr, copy_size);
PRINTK_AUDDRV("AudDrv_write u4BufferSize=%d, u4DataRemained=%d",
Afe_Block->u4BufferSize, Afe_Block->u4DataRemained);
} else {
PRINTK_AUD_DL1("memcpy Afe_Block->pucVirtBufAddr+Afe_WriteIdx=%p, data_w_ptr=%p,
copy_size = 0x%x\n", Afe_Block->pucVirtBufAddr + Afe_WriteIdx_tmp,
data_w_ptr, copy_size);
if (copy_from_user
((Afe_Block->pucVirtBufAddr + Afe_WriteIdx_tmp), data_w_ptr,
copy_size)) {
PRINTK_AUDDRV("AudDrv_write Fail copy from user\n");
return -1;
}
}
spin_lock_irqsave(&auddrv_DL1BTCtl_lock, flags);
Afe_Block->u4DataRemained += copy_size;
Afe_Block->u4WriteIdx = Afe_WriteIdx_tmp + copy_size;
Afe_Block->u4WriteIdx %= Afe_Block->u4BufferSize;
spin_unlock_irqrestore(&auddrv_DL1BTCtl_lock, flags);
data_w_ptr += copy_size;
count -= copy_size;
PRINTK_AUD_DL1("AudDrv_write finish1, copy_size:%x, WriteIdx:%x, ReadIdx=%x,
DataRemained:%x, count=%lu \r\n", copy_size, Afe_Block->u4WriteIdx,
Afe_Block->u4DMAReadIdx, Afe_Block->u4DataRemained, count);
} else { /* copy twice */
static int mtk_asoc_dl1bt_remove(struct platform_device *pdev)
{
PRINTK_AUDDRV("%s\n", __func__);
snd_soc_unregister_platform(&pdev->dev);
return 0;
}
static int mtk_voice_bt_hw_free(struct snd_pcm_substream *substream)
{
PRINTK_AUDDRV("mtk_voice_bt_hw_free\n");
return snd_pcm_lib_free_pages(substream);
}
static int mtk_pcm_i2s0_copy(struct snd_pcm_substream *substream,
int channel, snd_pcm_uframes_t pos,
void __user *dst, snd_pcm_uframes_t count)
{
AFE_BLOCK_T *Afe_Block = NULL;
int copy_size = 0, Afe_WriteIdx_tmp;
unsigned long flags;
char *data_w_ptr = (char *)dst;
//struct snd_pcm_runtime *runtime = substream->runtime;
PRINTK_AUD_DL1("%s pos = 0x%x count = 0x%x\n ", __func__, pos, count);
count = audio_frame_to_bytes(substream , count);
// check which memif nned to be write
Afe_Block = &pI2s0MemControl->rBlock;
// handle for buffer management
PRINTK_AUD_DL1(" WriteIdx=0x%x, ReadIdx=0x%x, DataRemained=0x%x \n",
Afe_Block->u4WriteIdx, Afe_Block->u4DMAReadIdx, Afe_Block->u4DataRemained);
if (Afe_Block->u4BufferSize == 0)
{
printk(" u4BufferSize=0 Error");
return 0;
}
spin_lock_irqsave(&auddrv_I2S0_lock, flags);
copy_size = Afe_Block->u4BufferSize - Afe_Block->u4DataRemained; // free space of the buffer
spin_unlock_irqrestore(&auddrv_I2S0_lock, flags);
if (count <= copy_size)
{
if (copy_size < 0)
{
copy_size = 0;
}
else
{
copy_size = count;
}
}
copy_size = Align64ByteSize(copy_size);
PRINTK_AUD_DL1("copy_size=0x%x, count=0x%x \n", copy_size, count);
if (copy_size != 0)
{
spin_lock_irqsave(&auddrv_I2S0_lock, flags);
Afe_WriteIdx_tmp = Afe_Block->u4WriteIdx;
spin_unlock_irqrestore(&auddrv_I2S0_lock, flags);
if (Afe_WriteIdx_tmp + copy_size < Afe_Block->u4BufferSize) // copy once
{
if (!access_ok(VERIFY_READ, data_w_ptr, copy_size))
{
PRINTK_AUDDRV("0ptr invalid data_w_ptr=%p, size=%d", data_w_ptr, copy_size);
PRINTK_AUDDRV(" u4BufferSize=%d, u4DataRemained=%d", Afe_Block->u4BufferSize, Afe_Block->u4DataRemained);
}
else
{
PRINTK_AUD_DL1("memcpy Afe_Block->pucVirtBufAddr+Afe_WriteIdx= 0x%x data_w_ptr = %p copy_size = 0x%x\n",
Afe_Block->pucVirtBufAddr + Afe_WriteIdx_tmp, data_w_ptr, copy_size);
if (copy_from_user((Afe_Block->pucVirtBufAddr + Afe_WriteIdx_tmp), data_w_ptr, copy_size))
{
PRINTK_AUDDRV(" Fail copy from user \n");
return -1;
}
}
spin_lock_irqsave(&auddrv_I2S0_lock, flags);
Afe_Block->u4DataRemained += copy_size;
Afe_Block->u4WriteIdx = Afe_WriteIdx_tmp + copy_size;
Afe_Block->u4WriteIdx %= Afe_Block->u4BufferSize;
spin_unlock_irqrestore(&auddrv_I2S0_lock, flags);
data_w_ptr += copy_size;
count -= copy_size;
PRINTK_AUD_DL1(" finish1, copy_size:%x, WriteIdx:%x, ReadIdx=%x, DataRemained:%x, count=%x \r\n",
copy_size, Afe_Block->u4WriteIdx, Afe_Block->u4DMAReadIdx, Afe_Block->u4DataRemained, count);
}
else // copy twice
{
kal_uint32 size_1 = 0, size_2 = 0;
size_1 = Align64ByteSize((Afe_Block->u4BufferSize - Afe_WriteIdx_tmp));
size_2 = Align64ByteSize((copy_size - size_1));
PRINTK_AUD_DL1("size_1=0x%x, size_2=0x%x \n", size_1, size_2);
if (!access_ok(VERIFY_READ, data_w_ptr, size_1))
{
printk(" 1ptr invalid data_w_ptr=%p, size_1=%d", data_w_ptr, size_1);
printk(" u4BufferSize=%d, u4DataRemained=%d", Afe_Block->u4BufferSize, Afe_Block->u4DataRemained);
}
else
{
PRINTK_AUD_DL1("mcmcpy Afe_Block->pucVirtBufAddr+Afe_WriteIdx= %x data_w_ptr = %p size_1 = %x\n",
Afe_Block->pucVirtBufAddr + Afe_WriteIdx_tmp, data_w_ptr, size_1);
if ((copy_from_user((Afe_Block->pucVirtBufAddr + Afe_WriteIdx_tmp), data_w_ptr , size_1)))
{
PRINTK_AUDDRV(" Fail 1 copy from user");
return -1;
}
}
spin_lock_irqsave(&auddrv_I2S0_lock, flags);
Afe_Block->u4DataRemained += size_1;
Afe_Block->u4WriteIdx = Afe_WriteIdx_tmp + size_1;
Afe_Block->u4WriteIdx %= Afe_Block->u4BufferSize;
Afe_WriteIdx_tmp = Afe_Block->u4WriteIdx;
spin_unlock_irqrestore(&auddrv_I2S0_lock, flags);
if (!access_ok(VERIFY_READ, data_w_ptr + size_1, size_2))
{
PRINTK_AUDDRV("2ptr invalid data_w_ptr=%p, size_1=%d, size_2=%d", data_w_ptr, size_1, size_2);
PRINTK_AUDDRV("u4BufferSize=%d, u4DataRemained=%d", Afe_Block->u4BufferSize, Afe_Block->u4DataRemained);
}
else
{
PRINTK_AUD_DL1("mcmcpy Afe_Block->pucVirtBufAddr+Afe_WriteIdx= %x data_w_ptr+size_1 = %p size_2 = %x\n",
Afe_Block->pucVirtBufAddr + Afe_WriteIdx_tmp, data_w_ptr + size_1, size_2);
if ((copy_from_user((Afe_Block->pucVirtBufAddr + Afe_WriteIdx_tmp), (data_w_ptr + size_1), size_2)))
{
PRINTK_AUDDRV("AudDrv_write Fail 2 copy from user");
return -1;
}
}
spin_lock_irqsave(&auddrv_I2S0_lock, flags);
Afe_Block->u4DataRemained += size_2;
Afe_Block->u4WriteIdx = Afe_WriteIdx_tmp + size_2;
Afe_Block->u4WriteIdx %= Afe_Block->u4BufferSize;
spin_unlock_irqrestore(&auddrv_I2S0_lock, flags);
count -= copy_size;
data_w_ptr += copy_size;
PRINTK_AUD_DL1(" finish2, copy size:%x, WriteIdx:%x,ReadIdx=%x DataRemained:%x \r\n",
copy_size, Afe_Block->u4WriteIdx, Afe_Block->u4DMAReadIdx, Afe_Block->u4DataRemained);
}
}
return 0;
PRINTK_AUD_DL1("pcm_copy return \n");
}
