csl_dmachannelaux.h

dsp在音频处理中的运用

#ifndef _CSL_DMACHANNELAUX_H
#define _CSL_DMACHANNELAUX_H

#ifdef __cplusplus
extern "C" {
#endif

static inline
void
	CSL_dmaChangeDataType (
		CSL_DmaHandle 			hDma,
		CSL_DmaDataType 		datatype
)
{
	CSL_FINS(hDma->regs->CSDP, DMA_CSDP_DATATYPE, datatype);
}

static inline
void
	CSL_dmaChangeChannelCtrlSetup (
		CSL_DmaHandle 			hDma,
		CSL_DmaSetupChaCtrl     	*chaCtrlSetup
)
{	register Uint32 _dma_ccr;       /* Local copy of CCR Register  */
 	_dma_ccr = hDma->regs->CCR;

 	CSL_FINS(_dma_ccr, DMA_CCR_SYNC, chaCtrlSetup->sync);
 	CSL_FINS(_dma_ccr, DMA_CCR_FS, chaCtrlSetup->fs);
 	CSL_FINS(_dma_ccr, DMA_CCR_PRIO, chaCtrlSetup->priority);
 	CSL_FINS(_dma_ccr, DMA_CCR_AUTOINIT, chaCtrlSetup->autoinit);
	CSL_FINS(_dma_ccr, DMA_CCR_ENDPROG, chaCtrlSetup->endprog);
	CSL_FINS(_dma_ccr, DMA_CCR_REPEAT, chaCtrlSetup->repeat);
	CSL_FINS(_dma_ccr, DMA_CCR_OMAP31COMPATDISAB, chaCtrlSetup->compatability);

	hDma->regs->CCR = _dma_ccr;

}

static inline
void
	CSL_dmaEnableInterrupt (
		CSL_DmaHandle 			hDma,
		Uint16				intMask
)
{
	hDma->regs->CICR |= intMask;
}


static inline
void
	CSL_dmaDisableInterrupt (
		CSL_DmaHandle 			hDma,
		Uint16				intMask
)
{
	hDma->regs->CICR &= ~(intMask);
}


static inline
void
	CSL_dmaChangeElementCount (
		CSL_DmaHandle 			hDma,
		Uint16				elecount
)
{
	hDma->regs->CEN = elecount;
}


static inline
void
	CSL_dmaChangeFrameCount (
		CSL_DmaHandle 			hDma,
		Uint16				framecount
)
{
	hDma->regs->CFN = framecount;
}


static inline
void
	CSL_dmaChangeLCHType (
		CSL_DmaHandle 			hDma,
		CSL_DmaLchType			lchType
)
{

	CSL_FINS(hDma->regs->LCHCTRL, DMA_LCHCTRL_LCHTYPE, lchType);
}


static inline
void
	CSL_dmaChangeLCHInterleave (
		CSL_DmaHandle 			hDma,
		CSL_DmaLchInterleave		lchInterleave
)
{

	CSL_FINS(hDma->regs->LCHCTRL, DMA_LCHCTRL_LCHINTERLEAVEDISAB, lchInterleave);
}

static inline
void
	CSL_dmaChangeLCHLinkSetup(
		CSL_DmaHandle 			hDma,
		CSL_DmaSetupLchLink    		*lchLinkSetup
)
{
	hDma->regs->CLNKCTRL = CSL_FMK(DMA_CLNKCTRL_ENABLNK,lchLinkSetup->lchLink) | \
		CSL_FMK(DMA_CLNKCTRL_STOPLNK,lchLinkSetup->lchStopLink) | \
		CSL_FMK(DMA_CLNKCTRL_NEXTCHID,lchLinkSetup->nextLch);
}


static inline
void
	CSL_dmaChangeGraphicSetup(
		CSL_DmaHandle 			hDma,
		CSL_DmaSetupGraphic    		*graphicSetup
)
{
    hDma->regs->CCR2 = CSL_FMK(DMA_CCR2_BS, graphicSetup->blockSync) | \
         CSL_FMK(DMA_CCR2_TRANSCOPYENAB, graphicSetup->transparentCopy) | \
         CSL_FMK(DMA_CCR2_CONSTFILLENAB, graphicSetup->constantFill);


}

static inline
void
	CSL_dmaEnableChannel (
		CSL_DmaHandle 			hDma
)
{
	CSL_FINS(hDma->regs->CCR, DMA_CCR_EN, 1);
}

static inline
void
	CSL_dmaDisableChannel (
		CSL_DmaHandle 			hDma
)
{
	CSL_FINS(hDma->regs->CCR, DMA_CCR_EN, 0);
}


static inline
void
	CSL_dmaGetChannelSetup (
		CSL_DmaHandle 			hDma,
		CSL_DmaSetupChannel		*channelSetup
)
{

	register Uint32 _dma_lchctrl;   /* Local copy of LCH Ctrl Register  */
       channelSetup->datatype=(CSL_DmaDataType)CSL_FEXT(hDma->regs->CSDP,DMA_CSDP_DATATYPE);
       channelSetup->interruptMask = hDma->regs->CICR;
       channelSetup->elementCount = hDma->regs->CEN;
       channelSetup->frameCount = hDma->regs->CFN;

       _dma_lchctrl = hDma->regs->LCHCTRL;
       channelSetup->lchType = (CSL_DmaLchType)CSL_FEXT(_dma_lchctrl, DMA_LCHCTRL_LCHTYPE);
       channelSetup->lchInterleave = (CSL_DmaLchInterleave)CSL_FEXT(_dma_lchctrl, DMA_LCHCTRL_LCHINTERLEAVEDISAB);

  }


static inline
void
	CSL_dmaGetChannelCtrlSetup (
		CSL_DmaHandle 			hDma,
		CSL_DmaSetupChaCtrl     *chaCtrlSetup
)
{

	register Uint32 _dma_ccr;       /* Local copy of CCR Register  */
	if (chaCtrlSetup != NULL) {
	     _dma_ccr = hDma->regs->CCR;

	     chaCtrlSetup->sync = (CSL_DmaSync) CSL_FEXT(_dma_ccr, DMA_CCR_SYNC);
	     chaCtrlSetup->fs = (CSL_DmaFS) CSL_FEXT(_dma_ccr, DMA_CCR_FS);
	     chaCtrlSetup->priority = (CSL_DmaPriority) CSL_FEXT(_dma_ccr, DMA_CCR_PRIO);
	     chaCtrlSetup->autoinit = (CSL_DmaAutoInit) CSL_FEXT(_dma_ccr, DMA_CCR_AUTOINIT);
	     chaCtrlSetup->endprog = (CSL_DmaEndProg) CSL_FEXT(_dma_ccr, DMA_CCR_ENDPROG);
	     chaCtrlSetup->repeat = (CSL_DmaRepeat) CSL_FEXT(_dma_ccr, DMA_CCR_REPEAT);
	     chaCtrlSetup->compatability = (CSL_DmaCompatability) CSL_FEXT(_dma_ccr, DMA_CCR_OMAP31COMPATDISAB);

	}

}

static inline
void
	CSL_dmaGetLCHLinkSetup (
		CSL_DmaHandle 			hDma,
		CSL_DmaSetupLchLink     *lchLinkSetup
)
{
	register Uint32 _dma_clnkctrl;  /* Local copy of CLNK Ctrl Register  */
       if (lchLinkSetup != NULL) {
	    _dma_clnkctrl = hDma->regs->CLNKCTRL;

	     lchLinkSetup->lchLink = (CSL_DmaLchLink) CSL_FEXT(_dma_clnkctrl, DMA_CLNKCTRL_ENABLNK);
	     lchLinkSetup->lchStopLink = (CSL_DmaLchStopLink) CSL_FEXT(_dma_clnkctrl, DMA_CLNKCTRL_STOPLNK);
	     lchLinkSetup->nextLch = CSL_FEXT(_dma_clnkctrl, DMA_CLNKCTRL_NEXTCHID);
       }
}


static inline
void
	CSL_dmaGetGraphicSetup (
		CSL_DmaHandle 			hDma,
		CSL_DmaSetupGraphic     *graphicSetup
)
{
	register Uint32 _dma_ccr2;      /* Local copy of CCR2 Register  */

	if (graphicSetup != NULL) {
	     _dma_ccr2 = hDma->regs->CCR2;

	     graphicSetup->blockSync = (CSL_DmaBlockSync) CSL_FEXT(_dma_ccr2, DMA_CCR2_BS);
	     graphicSetup->transparentCopy = (CSL_DmaTransparentCopy) CSL_FEXT(_dma_ccr2, DMA_CCR2_TRANSCOPYENAB);
	     graphicSetup->constantFill = (CSL_DmaConstantFill) CSL_FEXT(_dma_ccr2, DMA_CCR2_CONSTFILLENAB);
	     graphicSetup->colour = (hDma->regs->COLORL | (hDma->regs->COLORU << 16) );
	  }
}

static inline
void
	CSL_dmaGetStatus (
		CSL_DmaHandle 			hDma,
		CSL_DmaStatus			*dmaStatus
)
{
	register Uint32 _dma_csr;       /* Local copy of CSR Register  */
	_dma_csr = hDma->regs->CSR;

  	dmaStatus->interruptStatus = _dma_csr & 0x3f;
  	dmaStatus->syncStatus = (CSL_DmaSyncStatus) CSL_FEXT(_dma_csr, DMA_CSR_SYNC);
  	dmaStatus->configStatus = (CSL_DmaConfigStatus)CSL_FEXT(_dma_csr, DMA_CSR_CONFDISAB);
}


static inline
void
	CSL_dmaGetInterruptStatus (
		CSL_DmaHandle 			hDma,
		Uint16				*interruptStatus
)
{
	register Uint32 _dma_csr;       /* Local copy of CSR Register  */
        _dma_csr = hDma->regs->CSR;
        *interruptStatus = _dma_csr & 0x3f;
}

static inline
void
	CSL_dmaGetSyncStatus (
		CSL_DmaHandle 			hDma,
		CSL_DmaSyncStatus	    *syncStatus
)
{
	register Uint32 _dma_csr;       /* Local copy of CSR Register  */
        _dma_csr = hDma->regs->CSR;
        *syncStatus = (CSL_DmaSyncStatus) CSL_FEXT(_dma_csr, DMA_CSR_SYNC);
}

static inline
void
	CSl_dmaGetConfigStatus (
		CSL_DmaHandle 			hDma,
		CSL_DmaConfigStatus		*configStatus
)
{
	register Uint32 _dma_csr;       /* Local copy of CSR Register  */
	_dma_csr = hDma->regs->CSR;
        *configStatus = (CSL_DmaConfigStatus)CSL_FEXT(_dma_csr, DMA_CSR_CONFDISAB);
}

static inline
void
	CSL_dmaGetSrcAddrCnt (
		CSL_DmaHandle 			hDma,
		Uint16				*addressCounter
)
{
	*addressCounter = hDma->regs->CSAC;
}

static inline
void
	CSL_dmaGetDstAddrCnt (
		CSL_DmaHandle 			hDma,
		Uint16				*addressCounter
)
{
        *addressCounter = hDma->regs->CDAC;
}

#ifdef __cplusplus
}
#endif

#endif