static int mtk_pcm_mrgrx_copy(struct snd_pcm_substream *substream,
int channel, snd_pcm_uframes_t pos,
void __user *dst, snd_pcm_uframes_t count)
{
count = audio_frame_to_bytes(substream , count);
return count;
}
static int mtk_pcm_btcvsd_rx_copy(struct snd_pcm_substream *substream,
int channel, snd_pcm_uframes_t pos,
void __user *dst, snd_pcm_uframes_t count)
{
/* get total bytes to copy */
char *Read_Data_Ptr = (char *)dst;
count = audio_frame_to_bytes(substream , count);
count = Align64ByteSize(count);
AudDrv_btcvsd_read(Read_Data_Ptr, count);
LOGBT("pcm_copy return\n");
return 0;
}
static int mtk_fm_i2s_awb_pcm_copy(struct snd_pcm_substream *substream,
int channel, snd_pcm_uframes_t pos,
void __user *dst, snd_pcm_uframes_t count)
{
AFE_MEM_CONTROL_T *pAWB_MEM_ConTrol = NULL;
AFE_BLOCK_T *Awb_Block = NULL;
char *Read_Data_Ptr = (char *)dst;
ssize_t DMA_Read_Ptr = 0, read_size = 0, read_count = 0;
unsigned long flags;
/* get total bytes to copy */
#ifdef AUDIO_64BYTE_ALIGN
count = Align64ByteSize(audio_frame_to_bytes(substream, count));
#else
count = audio_frame_to_bytes(substream, count);
#endif
PRINTK_AUD_AWB("%s pos = %lu count = %lu\n ", __func__, pos, count);
/* check which memif nned to be write */
pAWB_MEM_ConTrol = FM_I2S_AWB_Control_context;
Awb_Block = &(pAWB_MEM_ConTrol->rBlock);
if (pAWB_MEM_ConTrol == NULL) {
pr_err("cannot find MEM control !!!!!!!\n");
msleep(50);
return 0;
}
if (Awb_Block->u4BufferSize <= 0) {
msleep(50);
return 0;
}
if (CheckNullPointer((void *)Awb_Block->pucVirtBufAddr)) {
pr_err("CheckNullPointer pucVirtBufAddr = %p\n", Awb_Block->pucVirtBufAddr);
return 0;
}
spin_lock_irqsave(&auddrv_AWBInCtl_lock, flags);
if (Awb_Block->u4DataRemained > Awb_Block->u4BufferSize) {
pr_warn("AudDrv_MEMIF_Read u4DataRemained=%x > u4BufferSize=%x" ,
Awb_Block->u4DataRemained, Awb_Block->u4BufferSize);
Awb_Block->u4DataRemained = 0;
Awb_Block->u4DMAReadIdx = Awb_Block->u4WriteIdx;
}
if (count > Awb_Block->u4DataRemained)
read_size = Awb_Block->u4DataRemained;
else
read_size = count;
DMA_Read_Ptr = Awb_Block->u4DMAReadIdx;
spin_unlock_irqrestore(&auddrv_AWBInCtl_lock, flags);
PRINTK_AUD_AWB("AudDrv_MEMIF_Read finish0, read_count:0x%x, read_size:0x%x, u4DataRemained:0x%x,
u4DMAReadIdx:0x%x, u4WriteIdx:0x%x \r\n", read_count, read_size, Awb_Block->u4DataRemained,
Awb_Block->u4DMAReadIdx, Awb_Block->u4WriteIdx);
if (DMA_Read_Ptr + read_size < Awb_Block->u4BufferSize) {
if (DMA_Read_Ptr != Awb_Block->u4DMAReadIdx) {
pr_warn
("%s 1, read_size:0x%zu, DataRemained:0x%x, DMA_Read_Ptr:0x%zu,DMAReadIdx:0x%x \r\n",
__func__, read_size, Awb_Block->u4DataRemained, DMA_Read_Ptr, Awb_Block->u4DMAReadIdx);
}
if (copy_to_user((void __user *)Read_Data_Ptr,
(Awb_Block->pucVirtBufAddr + DMA_Read_Ptr), read_size)) {
pr_err
("%s Fail1 Read_Data_Ptr:%p,pucVirtBufAddr:%p,DMAReadIdx:0x%x,DMA_Read_Ptr:0x%zu,read_size:%zu",
__func__, Read_Data_Ptr, Awb_Block->pucVirtBufAddr, Awb_Block->u4DMAReadIdx, DMA_Read_Ptr,
read_size);
return 0;
}
read_count += read_size;
spin_lock(&auddrv_AWBInCtl_lock);
Awb_Block->u4DataRemained -= read_size;
Awb_Block->u4DMAReadIdx += read_size;
Awb_Block->u4DMAReadIdx %= Awb_Block->u4BufferSize;
DMA_Read_Ptr = Awb_Block->u4DMAReadIdx;
spin_unlock(&auddrv_AWBInCtl_lock);
Read_Data_Ptr += read_size;
count -= read_size;
PRINTK_AUD_AWB("AudDrv_MEMIF_Read finish1, copy size:0x%x, u4DMAReadIdx:0x%x, u4WriteIdx:0x%x,
u4DataRemained:0x%x \r\n", read_size, Awb_Block->u4DMAReadIdx, Awb_Block->u4WriteIdx,
Awb_Block->u4DataRemained);
}
else {
static int mtk_mrgrx_awb_pcm_copy(struct snd_pcm_substream *substream,
int channel, snd_pcm_uframes_t pos,
void __user *dst, snd_pcm_uframes_t count)
{
AFE_MEM_CONTROL_T *pAWB_MEM_ConTrol = NULL;
AFE_BLOCK_T *Awb_Block = NULL;
char *Read_Data_Ptr = (char *)dst;
ssize_t DMA_Read_Ptr = 0 , read_size = 0, read_count = 0;
unsigned long flags;
// get total bytes to copy
count = Align64ByteSize(audio_frame_to_bytes(substream , count));
PRINTK_AUD_AWB("%s pos = %lu count = %lu\n ", __func__,pos, count);
// check which memif nned to be write
pAWB_MEM_ConTrol = Mrgrx_AWB_Control_context;
Awb_Block = &(pAWB_MEM_ConTrol->rBlock);
if (pAWB_MEM_ConTrol == NULL)
{
printk("cannot find MEM control !!!!!!!\n");
msleep(50);
return 0;
}
if (Awb_Block->u4BufferSize <= 0)
{
msleep(50);
return 0;
}
if (CheckNullPointer((void *)Awb_Block->pucVirtBufAddr))
{
printk("CheckNullPointer pucVirtBufAddr = %p\n", Awb_Block->pucVirtBufAddr);
return 0;
}
spin_lock_irqsave(&auddrv_AWBInCtl_lock, flags);
if (Awb_Block->u4DataRemained > Awb_Block->u4BufferSize)
{
printk("AudDrv_MEMIF_Read u4DataRemained=%x > u4BufferSize=%x" , Awb_Block->u4DataRemained, Awb_Block->u4BufferSize);
Awb_Block->u4DataRemained = 0;
Awb_Block->u4DMAReadIdx = Awb_Block->u4WriteIdx;
}
if (count > Awb_Block->u4DataRemained)
{
read_size = Awb_Block->u4DataRemained;
}
else
{
read_size = count;
}
DMA_Read_Ptr = Awb_Block->u4DMAReadIdx + Get_Mem_CopySizeByStream(Soc_Aud_Digital_Block_MEM_AWB,substream);
PRINTK_AUD_AWB("Awb_Block->u4DMAReadIdx= 0x%x Get_Mem_CopySizeByStream = 0x%x \r\n",
Awb_Block->u4DMAReadIdx ,Get_Mem_CopySizeByStream(Soc_Aud_Digital_Block_MEM_AWB,substream));
if(DMA_Read_Ptr >= Awb_Block->u4BufferSize )
{
DMA_Read_Ptr -=Awb_Block->u4BufferSize;
}
spin_unlock_irqrestore(&auddrv_AWBInCtl_lock, flags);
PRINTK_AUD_AWB("AudDrv_MEMIF_Read finish0, read_count:0x%x, read_size:0x%x, u4DataRemained:0x%x, u4DMAReadIdx:0x%x, u4WriteIdx:0x%x \r\n",
read_count, read_size, Awb_Block->u4DataRemained, Awb_Block->u4DMAReadIdx, Awb_Block->u4WriteIdx);
if (DMA_Read_Ptr + read_size <= Awb_Block->u4BufferSize)
{
if (DMA_Read_Ptr != Awb_Block->u4DMAReadIdx)
{
printk("AudDrv_MEMIF_Read 1, read_size:%zu, DataRemained:0x%x, DMA_Read_Ptr:%zu, DMAReadIdx:0x%x \r\n",
read_size, Awb_Block->u4DataRemained, DMA_Read_Ptr, Awb_Block->u4DMAReadIdx);
}
if (copy_to_user((void __user *)Read_Data_Ptr, (Awb_Block->pucVirtBufAddr + DMA_Read_Ptr), read_size))
{
printk("AudDrv_MEMIF_Read Fail 1 copy to user Read_Data_Ptr:%p, pucVirtBufAddr:%p, u4DMAReadIdx:0x%x, DMA_Read_Ptr:%zu,read_size:%zu", Read_Data_Ptr, Awb_Block->pucVirtBufAddr, Awb_Block->u4DMAReadIdx, DMA_Read_Ptr, read_size);
return 0;
}
read_count += read_size;
spin_lock(&auddrv_AWBInCtl_lock);
Set_Mem_CopySizeByStream(Soc_Aud_Digital_Block_MEM_AWB,substream,read_size);
spin_unlock(&auddrv_AWBInCtl_lock);
Read_Data_Ptr += read_size;
count -= read_size;
PRINTK_AUD_AWB("AudDrv_MEMIF_Read finish1, copy size:0x%x, u4DMAReadIdx:0x%x, u4WriteIdx:0x%x, u4DataRemained:0x%x u4MaxCopySize:0x%x \n",
read_size, Awb_Block->u4DMAReadIdx, Awb_Block->u4WriteIdx, Awb_Block->u4DataRemained,Get_Mem_CopySizeByStream(Soc_Aud_Digital_Block_MEM_AWB,substream));
}
else
{
uint32 size_1 , size_2;
size_1 = Awb_Block->u4BufferSize - DMA_Read_Ptr;
size_2 = read_size - size_1;
if (DMA_Read_Ptr != Awb_Block->u4DMAReadIdx)
{
printk("AudDrv_MEMIF_Read 2, read_size1:0x%x, DataRemained:0x%x, DMA_Read_Ptr:%zu, DMAReadIdx:0x%x \r\n",
size_1, Awb_Block->u4DataRemained, DMA_Read_Ptr, Awb_Block->u4DMAReadIdx);
}
if (copy_to_user((void __user *)Read_Data_Ptr, (Awb_Block->pucVirtBufAddr + DMA_Read_Ptr), size_1))
{
printk("AudDrv_MEMIF_Read Fail 2 copy to user Read_Data_Ptr:%p, pucVirtBufAddr:%p, u4DMAReadIdx:0x%x, DMA_Read_Ptr:%zu,read_size:%zu",
Read_Data_Ptr, Awb_Block->pucVirtBufAddr, Awb_Block->u4DMAReadIdx, DMA_Read_Ptr, read_size);
return 0;
}
read_count += size_1;
spin_lock(&auddrv_AWBInCtl_lock);
DMA_Read_Ptr += size_1;
Set_Mem_CopySizeByStream(Soc_Aud_Digital_Block_MEM_AWB,substream,size_1);
if(DMA_Read_Ptr >= Awb_Block->u4BufferSize )
{
DMA_Read_Ptr -= Awb_Block->u4BufferSize;
}
spin_unlock(&auddrv_AWBInCtl_lock);
PRINTK_AUD_AWB("AudDrv_MEMIF_Read finish2, copy size_1:0x%x, u4DMAReadIdx:0x%x, u4WriteIdx:0x%x, u4DataRemained:0x%x \r\n",
size_1, Awb_Block->u4DMAReadIdx, Awb_Block->u4WriteIdx, Awb_Block->u4DataRemained);
if (DMA_Read_Ptr != Awb_Block->u4DMAReadIdx)
{
PRINTK_AUD_AWB("AudDrv_AWB_Read 3, read_size2:%x, DataRemained:%x, DMA_Read_Ptr:0x%x, DMAReadIdx:%x \r\n",
size_2, Awb_Block->u4DataRemained, DMA_Read_Ptr, Awb_Block->u4DMAReadIdx);
}
if (copy_to_user((void __user *)(Read_Data_Ptr + size_1), (Awb_Block->pucVirtBufAddr + DMA_Read_Ptr), size_2))
{
printk("AudDrv_MEMIF_Read Fail 3 copy to user Read_Data_Ptr:%p, pucVirtBufAddr:%p, u4DMAReadIdx:0x%x , DMA_Read_Ptr:0x%zu, read_size:%zu", Read_Data_Ptr, Awb_Block->pucVirtBufAddr, Awb_Block->u4DMAReadIdx, DMA_Read_Ptr, read_size);
return read_count << 2;
}
read_count += size_2;
spin_lock(&auddrv_AWBInCtl_lock);
DMA_Read_Ptr += size_2;
Set_Mem_CopySizeByStream(Soc_Aud_Digital_Block_MEM_AWB,substream,size_2);
spin_unlock(&auddrv_AWBInCtl_lock);
count -= read_size;
Read_Data_Ptr += read_size;
PRINTK_AUD_AWB("AudDrv_MEMIF_Read finish3, copy size_2:0x%x, u4DMAReadIdx:0x%x, u4WriteIdx:0x%x u4DataRemained:0x%x \r\n",
size_2, Awb_Block->u4DMAReadIdx, Awb_Block->u4WriteIdx, Awb_Block->u4DataRemained);
}
return read_count >> 2;
}
static int mtk_bt_dai_pcm_copy(struct snd_pcm_substream *substream,
int channel, snd_pcm_uframes_t pos,
void __user *dst, snd_pcm_uframes_t count)
{
AFE_MEM_CONTROL_T *pDAI_MEM_ConTrol = NULL;
AFE_BLOCK_T *Dai_Block = NULL;
char *Read_Data_Ptr = (char *)dst;
ssize_t DMA_Read_Ptr = 0 , read_size = 0, read_count = 0;
unsigned long flags;
printk("%s pos = %lu count = %lu\n ", __func__, pos, count);
// get total bytes to copy
count =audio_frame_to_bytes(substream , count);
// check which memif nned to be write
pDAI_MEM_ConTrol = Bt_Dai_Control_context;
Dai_Block = &(pDAI_MEM_ConTrol->rBlock);
if (pDAI_MEM_ConTrol == NULL)
{
printk("cannot find MEM control !!!!!!!\n");
msleep(50);
return 0;
}
if (Dai_Block->u4BufferSize <= 0)
{
msleep(50);
return 0;
}
if (CheckNullPointer((void *)Dai_Block->pucVirtBufAddr))
{
printk("CheckNullPointer pucVirtBufAddr = %p\n", Dai_Block->pucVirtBufAddr);
return 0;
}
spin_lock_irqsave(&auddrv_BTDaiInCtl_lock, flags);
if (Dai_Block->u4DataRemained > Dai_Block->u4BufferSize)
{
PRINTK_AUD_DAI("!!!!!!!!!!!!mtk_bt_dai_pcm_copy u4DataRemained=%x > u4BufferSize=%x" , Dai_Block->u4DataRemained, Dai_Block->u4BufferSize);
Dai_Block->u4DataRemained = 0;
Dai_Block->u4DMAReadIdx = Dai_Block->u4WriteIdx;
}
if (count > Dai_Block->u4DataRemained)
{
read_size = Dai_Block->u4DataRemained;
}
else
{
read_size = count;
}
DMA_Read_Ptr = Dai_Block->u4DMAReadIdx;
spin_unlock_irqrestore(&auddrv_BTDaiInCtl_lock, flags);
PRINTK_AUD_DAI("mtk_bt_dai_pcm_copy finish0, read_count:0x%x, read_size:0x%x, u4DataRemained:0x%x, u4DMAReadIdx:0x%x, u4WriteIdx:0x%x \r\n",
read_count, read_size, Dai_Block->u4DataRemained, Dai_Block->u4DMAReadIdx, Dai_Block->u4WriteIdx);
if (DMA_Read_Ptr + read_size < Dai_Block->u4BufferSize)
{
if (DMA_Read_Ptr != Dai_Block->u4DMAReadIdx)
{
printk("mtk_bt_dai_pcm_copy 1, read_size:0x%x, DataRemained:0x%x, DMA_Read_Ptr:0x%x, DMAReadIdx:0x%x \r\n",
read_size, Dai_Block->u4DataRemained, DMA_Read_Ptr, Dai_Block->u4DMAReadIdx);
}
if (copy_to_user((void __user *)Read_Data_Ptr, (Dai_Block->pucVirtBufAddr + DMA_Read_Ptr), read_size))
{
printk("mtk_bt_dai_pcm_copy Fail 1 copy to user Read_Data_Ptr:%p, pucVirtBufAddr:%p, u4DMAReadIdx:0x%x, DMA_Read_Ptr:0x%x,read_size:%x", Read_Data_Ptr, Dai_Block->pucVirtBufAddr, Dai_Block->u4DMAReadIdx, DMA_Read_Ptr, read_size);
return 0;
}
read_count += read_size;
spin_lock(&auddrv_BTDaiInCtl_lock);
Dai_Block->u4DataRemained -= read_size;
Dai_Block->u4DMAReadIdx += read_size;
Dai_Block->u4DMAReadIdx %= Dai_Block->u4BufferSize;
DMA_Read_Ptr = Dai_Block->u4DMAReadIdx;
spin_unlock(&auddrv_BTDaiInCtl_lock);
Read_Data_Ptr += read_size;
count -= read_size;
PRINTK_AUD_DAI("mtk_bt_dai_pcm_copy finish1, copy size:0x%x, u4DMAReadIdx:0x%x, u4WriteIdx:0x%x, u4DataRemained:0x%x \r\n",
read_size, Dai_Block->u4DMAReadIdx, Dai_Block->u4WriteIdx, Dai_Block->u4DataRemained);
}
else
{
uint32 size_1 = Dai_Block->u4BufferSize - DMA_Read_Ptr;
uint32 size_2 = read_size - size_1;
if (DMA_Read_Ptr != Dai_Block->u4DMAReadIdx)
{
printk("mtk_bt_dai_pcm_copy 2, read_size1:0x%x, DataRemained:0x%x, DMA_Read_Ptr:0x%x, DMAReadIdx:0x%x \r\n",
size_1, Dai_Block->u4DataRemained, DMA_Read_Ptr, Dai_Block->u4DMAReadIdx);
}
if (copy_to_user((void __user *)Read_Data_Ptr, (Dai_Block->pucVirtBufAddr + DMA_Read_Ptr), size_1))
{
printk("mtk_bt_dai_pcm_copy Fail 2 copy to user Read_Data_Ptr:%p, pucVirtBufAddr:%p, u4DMAReadIdx:0x%x, DMA_Read_Ptr:0x%x,read_size:%x",
Read_Data_Ptr, Dai_Block->pucVirtBufAddr, Dai_Block->u4DMAReadIdx, DMA_Read_Ptr, read_size);
return 0;
}
read_count += size_1;
spin_lock(&auddrv_BTDaiInCtl_lock);
Dai_Block->u4DataRemained -= size_1;
Dai_Block->u4DMAReadIdx += size_1;
Dai_Block->u4DMAReadIdx %= Dai_Block->u4BufferSize;
DMA_Read_Ptr = Dai_Block->u4DMAReadIdx;
spin_unlock(&auddrv_BTDaiInCtl_lock);
PRINTK_AUD_DAI("mtk_bt_dai_pcm_copy finish2, copy size_1:0x%x, u4DMAReadIdx:0x%x, u4WriteIdx:0x%x, u4DataRemained:0x%x \r\n",
size_1, Dai_Block->u4DMAReadIdx, Dai_Block->u4WriteIdx, Dai_Block->u4DataRemained);
if (DMA_Read_Ptr != Dai_Block->u4DMAReadIdx)
{
printk("mtk_bt_dai_pcm_copy 3, read_size2:%x, DataRemained:%x, DMA_Read_Ptr:0x%x, DMAReadIdx:%x \r\n",
size_2, Dai_Block->u4DataRemained, DMA_Read_Ptr, Dai_Block->u4DMAReadIdx);
}
if (copy_to_user((void __user *)(Read_Data_Ptr + size_1), (Dai_Block->pucVirtBufAddr + DMA_Read_Ptr), size_2))
{
printk("mtk_bt_dai_pcm_copy Fail 3 copy to user Read_Data_Ptr:%p, pucVirtBufAddr:%p, u4DMAReadIdx:0x%x , DMA_Read_Ptr:0x%x, read_size:%x", Read_Data_Ptr, Dai_Block->pucVirtBufAddr, Dai_Block->u4DMAReadIdx, DMA_Read_Ptr, read_size);
return read_count << 2;
}
read_count += size_2;
spin_lock(&auddrv_BTDaiInCtl_lock);
Dai_Block->u4DataRemained -= size_2;
Dai_Block->u4DMAReadIdx += size_2;
DMA_Read_Ptr = Dai_Block->u4DMAReadIdx;
spin_unlock(&auddrv_BTDaiInCtl_lock);
count -= read_size;
Read_Data_Ptr += read_size;
PRINTK_AUD_DAI("mtk_bt_dai_pcm_copy finish3, copy size_2:0x%x, u4DMAReadIdx:0x%x, u4WriteIdx:0x%x u4DataRemained:0x%x \r\n",
size_2, Dai_Block->u4DMAReadIdx, Dai_Block->u4WriteIdx, Dai_Block->u4DataRemained);
}
return audio_bytes_to_frame(substream,count);
}
static int mtk_pcm_fmtx_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;
// get total bytes to copy
count = audio_frame_to_bytes(substream , count);
PRINTK_AUD_FMTX("[mtk_pcm_fmtx_copy] pos = %lu count = %lu\n ", pos, count);
// check which memif nned to be write
Afe_Block = &pMemControl->rBlock;
// handle for buffer management
PRINTK_AUD_FMTX("[mtk_pcm_fmtx_copy]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)
{
printk("AudDrv_write: u4BufferSize=0 Error");
return 0;
}
spin_lock_irqsave(&auddrv_FMTxCtl_lock, flags);
copy_size = Afe_Block->u4BufferSize - Afe_Block->u4DataRemained; // free space of the buffer
spin_unlock_irqrestore(&auddrv_FMTxCtl_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_FMTxCtl_lock, flags);
Afe_WriteIdx_tmp = Afe_Block->u4WriteIdx;
spin_unlock_irqrestore(&auddrv_FMTxCtl_lock, flags);
if (Afe_WriteIdx_tmp + copy_size < Afe_Block->u4BufferSize) // copy once
{
if (!access_ok(VERIFY_READ, data_w_ptr, copy_size))
{
PRINTK_AUD_FMTX("[mtk_pcm_fmtx_copy] 0ptr invalid data_w_ptr=0x%x, size=%d", (kal_uint32)data_w_ptr, copy_size);
PRINTK_AUD_FMTX("[mtk_pcm_fmtx_copy] u4BufferSize=%d, u4DataRemained=%d", Afe_Block->u4BufferSize, Afe_Block->u4DataRemained);
}
else
{
PRINTK_AUD_FMTX("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_AUD_FMTX("[mtk_pcm_fmtx_copy] Fail copy from user \n");
return -1;
}
}
spin_lock_irqsave(&auddrv_FMTxCtl_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_FMTxCtl_lock, flags);
data_w_ptr += copy_size;
count -= copy_size;
PRINTK_AUD_FMTX("[mtk_pcm_fmtx_copy] 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("[mtk_pcm_fmtx_copy] 1ptr invalid data_w_ptr=%p, size_1=%d", data_w_ptr, size_1);
printk("[mtk_pcm_fmtx_copy] u4BufferSize=%d, u4DataRemained=%d", Afe_Block->u4BufferSize, Afe_Block->u4DataRemained);
}
else
{
PRINTK_AUD_FMTX("[mtk_pcm_fmtx_copy]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_AUD_FMTX("[mtk_pcm_fmtx_copy] Fail 1 copy from user");
return -1;
}
}
spin_lock_irqsave(&auddrv_FMTxCtl_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_FMTxCtl_lock, flags);
if (!access_ok(VERIFY_READ, data_w_ptr + size_1, size_2))
{
PRINTK_AUD_FMTX("[mtk_pcm_fmtx_copy] 2ptr invalid data_w_ptr=%x, size_1=%d, size_2=%d", (kal_uint32)data_w_ptr, size_1, size_2);
PRINTK_AUD_FMTX("[mtk_pcm_fmtx_copy] u4BufferSize=%d, u4DataRemained=%d", Afe_Block->u4BufferSize, Afe_Block->u4DataRemained);
}
else
{
PRINTK_AUD_FMTX("[mtk_pcm_fmtx_copy]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_AUD_FMTX("[mtk_pcm_fmtx_copy] Fail 2 copy from user");
return -1;
}
}
spin_lock_irqsave(&auddrv_FMTxCtl_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_FMTxCtl_lock, flags);
count -= copy_size;
data_w_ptr += copy_size;
PRINTK_AUD_FMTX("[mtk_pcm_fmtx_copy] 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_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_capture_pcm_copy(struct snd_pcm_substream *substream,
int channel, snd_pcm_uframes_t pos,
void __user *dst, snd_pcm_uframes_t count)
{
AFE_MEM_CONTROL_T *pVUL_MEM_ConTrol = NULL;
AFE_BLOCK_T *Vul_Block = NULL;
char *Read_Data_Ptr = (char *)dst;
ssize_t DMA_Read_Ptr = 0 , read_size = 0, read_count = 0;
//struct snd_pcm_runtime *runtime = substream->runtime;
unsigned long flags;
PRINTK_AUD_UL1("mtk_capture_pcm_copy pos = %lucount = %lu \n ", pos, count);
// get total bytes to copy
count = Align64ByteSize(audio_frame_to_bytes(substream , count));
// check which memif nned to be write
pVUL_MEM_ConTrol = VUL_Control_context;
Vul_Block = &(pVUL_MEM_ConTrol->rBlock);
if (pVUL_MEM_ConTrol == NULL)
{
printk("cannot find MEM control !!!!!!!\n");
msleep(50);
return 0;
}
if (Vul_Block->u4BufferSize <= 0)
{
msleep(50);
printk("Vul_Block->u4BufferSize <= 0 =%d\n", Vul_Block->u4BufferSize);
return 0;
}
if (CheckNullPointer((void *)Vul_Block->pucVirtBufAddr))
{
printk("CheckNullPointer pucVirtBufAddr = %p\n", Vul_Block->pucVirtBufAddr);
return 0;
}
spin_lock_irqsave(&auddrv_ULInCtl_lock, flags);
if (Vul_Block->u4DataRemained > Vul_Block->u4BufferSize)
{
PRINTK_AUD_UL1("AudDrv_MEMIF_Read u4DataRemained=%x > u4BufferSize=%x" , Vul_Block->u4DataRemained, Vul_Block->u4BufferSize);
Vul_Block->u4DataRemained = 0;
Vul_Block->u4DMAReadIdx = Vul_Block->u4WriteIdx;
}
if (count > Vul_Block->u4DataRemained)
{
read_size = Vul_Block->u4DataRemained;
}
else
{
read_size = count;
}
DMA_Read_Ptr = Vul_Block->u4DMAReadIdx;
spin_unlock_irqrestore(&auddrv_ULInCtl_lock, flags);
PRINTK_AUD_UL1("AudDrv_MEMIF_Read finish0, read_count:%x, read_size:%x, u4DataRemained:%x, u4DMAReadIdx:0x%x, u4WriteIdx:%x \r\n",
(unsigned int)read_count, (unsigned int)read_size, Vul_Block->u4DataRemained, Vul_Block->u4DMAReadIdx, Vul_Block->u4WriteIdx);
if (DMA_Read_Ptr + read_size < Vul_Block->u4BufferSize)
{
if (DMA_Read_Ptr != Vul_Block->u4DMAReadIdx)
{
printk("AudDrv_MEMIF_Read 1, read_size:%zu, DataRemained:%x, DMA_Read_Ptr:0x%zu, DMAReadIdx:%x \r\n",
read_size, Vul_Block->u4DataRemained, DMA_Read_Ptr, Vul_Block->u4DMAReadIdx);
}
if (copy_to_user((void __user *)Read_Data_Ptr, (Vul_Block->pucVirtBufAddr + DMA_Read_Ptr), read_size))
{
printk("AudDrv_MEMIF_Read Fail 1 copy to user Read_Data_Ptr:%p, pucVirtBufAddr:%p, u4DMAReadIdx:0x%x, DMA_Read_Ptr:%zu,read_size:%zu", Read_Data_Ptr, Vul_Block->pucVirtBufAddr, Vul_Block->u4DMAReadIdx, DMA_Read_Ptr, read_size);
return 0;
}
read_count += read_size;
spin_lock(&auddrv_ULInCtl_lock);
Vul_Block->u4DataRemained -= read_size;
Vul_Block->u4DMAReadIdx += read_size;
Vul_Block->u4DMAReadIdx %= Vul_Block->u4BufferSize;
DMA_Read_Ptr = Vul_Block->u4DMAReadIdx;
spin_unlock(&auddrv_ULInCtl_lock);
Read_Data_Ptr += read_size;
count -= read_size;
PRINTK_AUD_UL1("AudDrv_MEMIF_Read finish1, copy size:%x, u4DMAReadIdx:0x%x, u4WriteIdx:%x, u4DataRemained:%x \r\n",
(unsigned int)read_size, Vul_Block->u4DMAReadIdx, Vul_Block->u4WriteIdx, Vul_Block->u4DataRemained);
}
else
{
uint32 size_1 = Vul_Block->u4BufferSize - DMA_Read_Ptr;
uint32 size_2 = read_size - size_1;
if (DMA_Read_Ptr != Vul_Block->u4DMAReadIdx)
{
printk("AudDrv_MEMIF_Read 2, read_size1:%x, DataRemained:%x, DMA_Read_Ptr:%zu, DMAReadIdx:%x \r\n",
size_1, Vul_Block->u4DataRemained, DMA_Read_Ptr, Vul_Block->u4DMAReadIdx);
}
if (copy_to_user((void __user *)Read_Data_Ptr, (Vul_Block->pucVirtBufAddr + DMA_Read_Ptr), (unsigned int)size_1))
{
printk("AudDrv_MEMIF_Read Fail 2 copy to user Read_Data_Ptr:%p, pucVirtBufAddr:%p, u4DMAReadIdx:0x%x, DMA_Read_Ptr:%zu,read_size:%zu",
Read_Data_Ptr, Vul_Block->pucVirtBufAddr, Vul_Block->u4DMAReadIdx, DMA_Read_Ptr, read_size);
return 0;
}
read_count += size_1;
spin_lock(&auddrv_ULInCtl_lock);
Vul_Block->u4DataRemained -= size_1;
Vul_Block->u4DMAReadIdx += size_1;
Vul_Block->u4DMAReadIdx %= Vul_Block->u4BufferSize;
DMA_Read_Ptr = Vul_Block->u4DMAReadIdx;
spin_unlock(&auddrv_ULInCtl_lock);
PRINTK_AUD_UL1("AudDrv_MEMIF_Read finish2, copy size_1:%x, u4DMAReadIdx:0x%x, u4WriteIdx:0x%x, u4DataRemained:%x \r\n",
size_1, Vul_Block->u4DMAReadIdx, Vul_Block->u4WriteIdx, Vul_Block->u4DataRemained);
if (DMA_Read_Ptr != Vul_Block->u4DMAReadIdx)
{
printk("AudDrv_AWB_Read 3, read_size2:%x, DataRemained:%x, DMA_Read_Ptr:%zu, DMAReadIdx:%x \r\n",
size_2, Vul_Block->u4DataRemained, DMA_Read_Ptr, Vul_Block->u4DMAReadIdx);
}
if (copy_to_user((void __user *)(Read_Data_Ptr + size_1), (Vul_Block->pucVirtBufAddr + DMA_Read_Ptr), size_2))
{
printk("AudDrv_MEMIF_Read Fail 3 copy to user Read_Data_Ptr:%p, pucVirtBufAddr:%p, u4DMAReadIdx:0x%x , DMA_Read_Ptr:%zu, read_size:%zu", Read_Data_Ptr, Vul_Block->pucVirtBufAddr, Vul_Block->u4DMAReadIdx, DMA_Read_Ptr, read_size);
return read_count << 2;
}
read_count += size_2;
spin_lock(&auddrv_ULInCtl_lock);
Vul_Block->u4DataRemained -= size_2;
Vul_Block->u4DMAReadIdx += size_2;
DMA_Read_Ptr = Vul_Block->u4DMAReadIdx;
spin_unlock(&auddrv_ULInCtl_lock);
count -= read_size;
Read_Data_Ptr += read_size;
PRINTK_AUD_UL1("AudDrv_MEMIF_Read finish3, copy size_2:%x, u4DMAReadIdx:0x%x, u4WriteIdx:0x%x u4DataRemained:%x \r\n",
size_2, Vul_Block->u4DMAReadIdx, Vul_Block->u4WriteIdx, Vul_Block->u4DataRemained);
}
return read_count >> 2;
}
static int mtk_pcm_hdmi_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;
count = audio_frame_to_bytes(substream, count);
/* check which memif need to be write */
Afe_Block = &(pMemControl->rBlock);
/* handle for buffer management */
PRINTK_AUD_HDMI
("[%s] count = %d, WriteIdx = %x, ReadIdx = %x, DataRemained = %x\n",
__func__, (kal_uint32) count, Afe_Block->u4WriteIdx,
Afe_Block->u4DMAReadIdx, Afe_Block->u4DataRemained);
if (Afe_Block->u4BufferSize == 0) {
pr_err("%s: u4BufferSize = 0, Error!!!\n", __func__);
return 0;
}
spin_lock_irqsave(&auddrv_hdmi_lock, flags);
/* free space of the buffer */
copy_size = Afe_Block->u4BufferSize - Afe_Block->u4DataRemained;
spin_unlock_irqrestore(&auddrv_hdmi_lock, flags);
if (count <= copy_size) {
if (copy_size < 0)
copy_size = 0;
else
copy_size = count;
}
if (copy_size != 0) {
spin_lock_irqsave(&auddrv_hdmi_lock, flags);
Afe_WriteIdx_tmp = Afe_Block->u4WriteIdx;
spin_unlock_irqrestore(&auddrv_hdmi_lock, flags);
if (Afe_WriteIdx_tmp + copy_size < Afe_Block->u4BufferSize) { /* copy once */
if (!access_ok(VERIFY_READ, data_w_ptr, copy_size)) {
pr_warn("[%s] 0 ptr invalid data_w_ptr = %p, size = %d,", __func__,
data_w_ptr, copy_size);
pr_warn(" u4BufferSize = %d, u4DataRemained = %d\n",
Afe_Block->u4BufferSize, Afe_Block->u4DataRemained);
} else {
PRINTK_AUD_HDMI2
("[%s] memcpy Afe_Block->pucVirtBufAddr+Afe_WriteIdx=%x, data_w_ptr=%p, copy_size=%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)) {
pr_err("[%s] Fail copy from user\n", __func__);
return -1;
}
}
spin_lock_irqsave(&auddrv_hdmi_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_hdmi_lock, flags);
data_w_ptr += copy_size;
count -= copy_size;
PRINTK_AUD_HDMI2
("[%s] finish 1, copy_size:%x, WriteIdx:%x, ReadIdx:%x, DataRemained:%x\n",
__func__, copy_size, Afe_Block->u4WriteIdx, Afe_Block->u4DMAReadIdx,
Afe_Block->u4DataRemained);
} else { /* copy twice */
kal_uint32 size_1 = 0, size_2 = 0;
size_1 = Afe_Block->u4BufferSize - Afe_WriteIdx_tmp;
size_2 = copy_size - size_1;
if (!access_ok(VERIFY_READ, data_w_ptr, size_1)) {
pr_warn("[%s] 1 ptr invalid data_w_ptr = %p, size_1 = %d,",
__func__, data_w_ptr, size_1);
pr_warn(" u4BufferSize = %d, u4DataRemained = %d\n",
Afe_Block->u4BufferSize, Afe_Block->u4DataRemained);
} else {
PRINTK_AUD_HDMI2
("[%s] mcmcpy Afe_Block->pucVirtBufAddr+Afe_WriteIdx=%x, data_w_ptr=%p, size_1=%x\n",
__func__, 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))) {
pr_err("[%s] Fail 1 copy from user\n", __func__);
return -1;
}
}
spin_lock_irqsave(&auddrv_hdmi_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_hdmi_lock, flags);
if (!access_ok(VERIFY_READ, data_w_ptr + size_1, size_2)) {
pr_warn("[%s] 2 ptr invalid data_w_ptr = %p, size_1 = %d, size_2 = %d,",
__func__, data_w_ptr, size_1, size_2);
pr_warn(" u4BufferSize = %d, u4DataRemained = %d\n",
Afe_Block->u4BufferSize, Afe_Block->u4DataRemained);
} else {
PRINTK_AUD_HDMI2
("[%s] mcmcpy Afe_Block->pucVirtBufAddr+Afe_WriteIdx=%x,\n",
__func__, Afe_Block->pucVirtBufAddr + Afe_WriteIdx_tmp);
PRINTK_AUD_HDMI2
(" data_w_ptr+size_1=%p, size_2=%x\n", data_w_ptr + size_1, size_2);
if ((copy_from_user((Afe_Block->pucVirtBufAddr + Afe_WriteIdx_tmp),
(data_w_ptr + size_1), size_2))) {
pr_err("[%s] Fail 2 copy from user\n", __func__);
return -1;
}
}
spin_lock_irqsave(&auddrv_hdmi_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_hdmi_lock, flags);
count -= copy_size;
data_w_ptr += copy_size;
PRINTK_AUD_HDMI2
("[%s] finish 2, copy size:%x, WriteIdx:%x, ReadIdx:%x, DataRemained:%x\n",
__func__, copy_size, Afe_Block->u4WriteIdx, Afe_Block->u4DMAReadIdx,
Afe_Block->u4DataRemained);
}
}
return 0;
}
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_I2S0dl1_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_DL1("mtk_pcm_copy pos = %lu count = %lu\n ", pos, count);
#ifdef _DEBUG_6328_CLK
// printk("TEST_OUT = 0x%x\n", Ana_Get_Reg(TEST_OUT));
// printk("AFUNC_AUD_MON0 = 0x%x\n", Ana_Get_Reg(AFUNC_AUD_MON0));
// printk("AFUNC_AUD_MON1 = 0x%x\n", Ana_Get_Reg(AFUNC_AUD_MON1));
#endif
// get total bytes to copy
count = audio_frame_to_bytes(substream , count);
// check which memif nned to be write
Afe_Block = &pI2S0dl1MemControl->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_I2S0dl1_lock, flags);
copy_size = Afe_Block->u4BufferSize - Afe_Block->u4DataRemained; // free space of the buffer
spin_unlock_irqrestore(&auddrv_I2S0dl1_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, (unsigned int)count);
if (copy_size != 0)
{
spin_lock_irqsave(&auddrv_I2S0dl1_lock, flags);
Afe_WriteIdx_tmp = Afe_Block->u4WriteIdx;
spin_unlock_irqrestore(&auddrv_I2S0dl1_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= %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(" Fail copy from user \n");
return -1;
}
}
spin_lock_irqsave(&auddrv_I2S0dl1_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_I2S0dl1_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, (unsigned int)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= %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 , size_1)))
{
PRINTK_AUDDRV(" Fail 1 copy from user");
return -1;
}
}
spin_lock_irqsave(&auddrv_I2S0dl1_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_I2S0dl1_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= %p 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_I2S0dl1_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_I2S0dl1_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);
}
}
PRINTK_AUD_DL1("pcm_copy return \n");
return 0;
}
