mirror of
https://github.com/pvvx/RTL00_HelloWorld.git
synced 2025-03-31 03:56:41 +00:00
1450 lines
48 KiB
C
1450 lines
48 KiB
C
/*
|
|
* Routines to access hardware
|
|
*
|
|
* Copyright (c) 2013 Realtek Semiconductor Corp.
|
|
*
|
|
* This module is a confidential and proprietary property of RealTek and
|
|
* possession or use of this module requires written permission of RealTek.
|
|
*/
|
|
|
|
#include "rtl8195a.h"
|
|
#include "rtl_utility.h"
|
|
#include "osdep_api.h"
|
|
#include "hal_dac.h"
|
|
#include "hal_gdma.h"
|
|
|
|
#define DAC_STATIC_ALLOC 0
|
|
|
|
/* DAC SAL global variables declaration when kernel disabled */
|
|
|
|
#if DAC_STATIC_ALLOC
|
|
SRAM_BF_DATA_SECTION
|
|
HAL_DAC_OP HalDACOpSAL;
|
|
#endif
|
|
|
|
|
|
#if DAC0_USED /*#if DAC0_USED*/
|
|
#if DAC_STATIC_ALLOC
|
|
SRAM_BF_DATA_SECTION
|
|
SAL_DAC_MNGT_ADPT SalDAC0MngtAdpt;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
SAL_DAC_HND_PRIV SalDAC0HndPriv;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
HAL_DAC_INIT_DAT HalDAC0InitData;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
IRQ_HANDLE DAC0IrqHandleDat;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
HAL_GDMA_ADAPTER HalDAC0GdmaAdpt;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
HAL_GDMA_OP HalDAC0GdmaOp;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
IRQ_HANDLE DAC0GDMAIrqHandleDat;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
SAL_DAC_USER_CB SalDAC0UserCB;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
SAL_DAC_DMA_USER_DEF SalDAC0DmaUserDef;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
SAL_DAC_USERCB_ADPT SalDAC0UserCBAdpt[SAL_DAC_USER_CB_NUM];
|
|
#endif
|
|
#endif /*#if DAC0_USED*/
|
|
|
|
#if DAC1_USED /*#if DAC1_USED*/
|
|
#if DAC_STATIC_ALLOC
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
SAL_DAC_MNGT_ADPT SalDAC1MngtAdpt;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
SAL_DAC_HND_PRIV SalDAC1HndPriv;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
HAL_DAC_INIT_DAT HalDAC1InitData;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
IRQ_HANDLE DAC1IrqHandleDat;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
HAL_GDMA_ADAPTER HalDAC1GdmaAdpt;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
HAL_GDMA_OP HalDAC1GdmaOp;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
IRQ_HANDLE DAC1GDMAIrqHandleDat;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
SAL_DAC_USER_CB SalDAC1UserCB;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
SAL_DAC_DMA_USER_DEF SalDAC1DmaUserDef;
|
|
|
|
SRAM_BF_DATA_SECTION
|
|
SAL_DAC_USERCB_ADPT SalDAC1UserCBAdpt[SAL_DAC_USER_CB_NUM];
|
|
#endif
|
|
#endif /*#if DAC1_USED*/
|
|
|
|
/* Function prototype */
|
|
VOID DACISRHandle(IN VOID *Data);
|
|
VOID DACGDMAISRHandle(IN VOID * Data);
|
|
VOID DACGDMALLPISRHandle(IN VOID *Data);
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//Function Name:
|
|
// RtkI2CGetMngtAdpt
|
|
//
|
|
// Description:
|
|
// According to the input index, all the memory space are allocated and all the
|
|
// related pointers are assigned. The management adapter pointer will be
|
|
// returned.
|
|
//
|
|
// Arguments:
|
|
// [in] u8 I2CIdx -
|
|
// I2C module index
|
|
//
|
|
// Return:
|
|
// PSAL_I2C_MNGT_ADPT
|
|
//
|
|
// Note:
|
|
// NA
|
|
//
|
|
// See Also:
|
|
// NA
|
|
//
|
|
// Author:
|
|
// By Jason Deng, 2014-04-02.
|
|
//
|
|
//---------------------------------------------------------------------------------------------------
|
|
VOID HalDACOpInit(
|
|
IN VOID *Data
|
|
)
|
|
{
|
|
PHAL_DAC_OP pHalDacOp = (PHAL_DAC_OP) Data;
|
|
|
|
pHalDacOp->HalDACInit = HalDACInit8195a;
|
|
pHalDacOp->HalDACDeInit = HalDACDeInit8195a;
|
|
pHalDacOp->HalDACEnable = HalDACEnableRtl8195a;
|
|
pHalDacOp->HalDACSend = HalDACSendRtl8195a;
|
|
pHalDacOp->HalDACIntrCtrl = HalDACIntrCtrl8195a;
|
|
pHalDacOp->HalDACReadReg = HalDACReadRegRtl8195a;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//Function Name:
|
|
// RtkI2CGetMngtAdpt
|
|
//
|
|
// Description:
|
|
// According to the input index, all the memory space are allocated and all the
|
|
// related pointers are assigned. The management adapter pointer will be
|
|
// returned.
|
|
//
|
|
// Arguments:
|
|
// [in] u8 I2CIdx -
|
|
// I2C module index
|
|
//
|
|
// Return:
|
|
// PSAL_I2C_MNGT_ADPT
|
|
//
|
|
// Note:
|
|
// NA
|
|
//
|
|
// See Also:
|
|
// NA
|
|
//
|
|
// Author:
|
|
// By Jason Deng, 2014-04-02.
|
|
//
|
|
//---------------------------------------------------------------------------------------------------
|
|
PSAL_DAC_MNGT_ADPT
|
|
RtkDACGetMngtAdpt(
|
|
IN u8 DACIdx
|
|
){
|
|
PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL;
|
|
PSAL_DAC_USERCB_ADPT pSalDACUserCBAdpt = NULL;
|
|
|
|
/* If the kernel is available, Memory-allocation is used. */
|
|
#if !DAC_STATIC_ALLOC
|
|
|
|
pSalDACMngtAdpt = (PSAL_DAC_MNGT_ADPT)RtlZmalloc(sizeof(SAL_DAC_MNGT_ADPT));
|
|
pSalDACMngtAdpt->pSalHndPriv = (PSAL_DAC_HND_PRIV)RtlZmalloc(sizeof(SAL_DAC_HND_PRIV));
|
|
pSalDACMngtAdpt->pHalInitDat = (PHAL_DAC_INIT_DAT)RtlZmalloc(sizeof(HAL_DAC_INIT_DAT));
|
|
pSalDACMngtAdpt->pHalOp = (PHAL_DAC_OP)RtlZmalloc(sizeof(HAL_DAC_OP));
|
|
pSalDACMngtAdpt->pIrqHnd = (PIRQ_HANDLE)RtlZmalloc(sizeof(IRQ_HANDLE));
|
|
pSalDACMngtAdpt->pUserCB = (PSAL_DAC_USER_CB)RtlZmalloc(sizeof(SAL_DAC_USER_CB));
|
|
pSalDACMngtAdpt->pDMAConf = (PSAL_DAC_DMA_USER_DEF)RtlZmalloc(sizeof(SAL_DAC_DMA_USER_DEF));
|
|
pSalDACMngtAdpt->pHalGdmaAdp = (PHAL_GDMA_ADAPTER)RtlZmalloc(sizeof(HAL_GDMA_ADAPTER));
|
|
pSalDACMngtAdpt->pHalGdmaOp = (PHAL_GDMA_OP)RtlZmalloc(sizeof(HAL_GDMA_OP));
|
|
pSalDACMngtAdpt->pIrqGdmaHnd = (PIRQ_HANDLE)RtlZmalloc(sizeof(IRQ_HANDLE));
|
|
pSalDACUserCBAdpt = (PSAL_DAC_USERCB_ADPT)RtlZmalloc((sizeof(SAL_DAC_USERCB_ADPT)*SAL_DAC_USER_CB_NUM));
|
|
#else
|
|
switch (DACIdx){
|
|
case DAC0_SEL:
|
|
{
|
|
pSalDACMngtAdpt = &SalDAC0MngtAdpt;
|
|
pSalDACMngtAdpt->pSalHndPriv = &SalDAC0HndPriv;
|
|
pSalDACMngtAdpt->pHalInitDat = &HalDAC0InitData;
|
|
pSalDACMngtAdpt->pHalOp = &HalDACOpSAL;
|
|
pSalDACMngtAdpt->pIrqHnd = &DAC0IrqHandleDat;
|
|
pSalDACMngtAdpt->pUserCB = &SalDAC0UserCB;
|
|
pSalDACMngtAdpt->pDMAConf = &SalDAC0DmaUserDef;
|
|
pSalDACMngtAdpt->pHalGdmaAdp = &HalDAC0GdmaAdpt;
|
|
pSalDACMngtAdpt->pHalGdmaOp = &HalDAC0GdmaOp;
|
|
pSalDACMngtAdpt->pIrqGdmaHnd = &DAC0IrqHandleDat;
|
|
pSalDACUserCBAdpt = &SalDAC0UserCBAdpt;
|
|
break;
|
|
}
|
|
|
|
case DAC1_SEL:
|
|
{
|
|
pSalDACMngtAdpt = &SalDAC1MngtAdpt;
|
|
pSalDACMngtAdpt->pSalHndPriv = &SalDAC1HndPriv;
|
|
pSalDACMngtAdpt->pHalInitDat = &HalDAC1InitData;
|
|
pSalDACMngtAdpt->pHalOp = &HalDACOpSAL;
|
|
pSalDACMngtAdpt->pIrqHnd = &DAC1IrqHandleDat;
|
|
pSalDACMngtAdpt->pUserCB = &SalDAC1UserCB;
|
|
pSalDACMngtAdpt->pDMAConf = &SalDAC1DmaUserDef;
|
|
pSalDACMngtAdpt->pHalGdmaAdp = &HalDAC1GdmaAdpt;
|
|
pSalDACMngtAdpt->pHalGdmaOp = &HalDAC1GdmaOp;
|
|
pSalDACMngtAdpt->pIrqGdmaHnd = &DAC1IrqHandleDat;
|
|
pSalDACUserCBAdpt = &SalDAC1UserCBAdpt;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
/*To assign user callback pointers*/
|
|
pSalDACMngtAdpt->pUserCB->pTXCB = pSalDACUserCBAdpt;
|
|
pSalDACMngtAdpt->pUserCB->pTXCCB = (pSalDACUserCBAdpt+1);
|
|
pSalDACMngtAdpt->pUserCB->pRXCB = (pSalDACUserCBAdpt+2);
|
|
pSalDACMngtAdpt->pUserCB->pRXCCB = (pSalDACUserCBAdpt+3);
|
|
pSalDACMngtAdpt->pUserCB->pRDREQCB = (pSalDACUserCBAdpt+4);
|
|
pSalDACMngtAdpt->pUserCB->pERRCB = (pSalDACUserCBAdpt+5);
|
|
pSalDACMngtAdpt->pUserCB->pDMATXCB = (pSalDACUserCBAdpt+6);
|
|
pSalDACMngtAdpt->pUserCB->pDMATXCCB = (pSalDACUserCBAdpt+7);
|
|
pSalDACMngtAdpt->pUserCB->pDMARXCB = (pSalDACUserCBAdpt+8);
|
|
pSalDACMngtAdpt->pUserCB->pDMARXCCB = (pSalDACUserCBAdpt+9);
|
|
|
|
/*To assign the rest pointers*/
|
|
pSalDACMngtAdpt->pSalHndPriv->ppSalDACHnd = (void**)&(pSalDACMngtAdpt->pSalHndPriv);
|
|
|
|
/* To assign the default HAL OP initialization function */
|
|
pSalDACMngtAdpt->pHalOpInit = &HalDACOpInit;
|
|
|
|
/* To assign the default HAL GDMA OP initialization function */
|
|
pSalDACMngtAdpt->pHalGdmaOpInit = &HalGdmaOpInit;
|
|
|
|
/* To assign the default SAL interrupt function */
|
|
pSalDACMngtAdpt->pSalIrqFunc = &DACISRHandle;
|
|
|
|
/* To assign the default SAL DMA interrupt function */
|
|
pSalDACMngtAdpt->pSalDMAIrqFunc = &DACGDMAISRHandle;
|
|
|
|
return pSalDACMngtAdpt;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//Function Name:
|
|
// RtkI2CFreeMngtAdpt
|
|
//
|
|
// Description:
|
|
// Free all the previous allocated memory space.
|
|
//
|
|
// Arguments:
|
|
// [in] PSAL_I2C_MNGT_ADPT pSalI2CMngtAdpt -
|
|
// I2C SAL management adapter pointer
|
|
//
|
|
//
|
|
// Return:
|
|
// The status of the enable process.
|
|
// _EXIT_SUCCESS if the RtkI2CFreeMngtAdpt succeeded.
|
|
// _EXIT_FAILURE if the RtkI2CFreeMngtAdpt failed.
|
|
//
|
|
// Note:
|
|
// NA
|
|
//
|
|
// See Also:
|
|
// NA
|
|
//
|
|
// Author:
|
|
// By Jason Deng, 2014-04-02.
|
|
//
|
|
//---------------------------------------------------------------------------------------------------
|
|
RTK_STATUS
|
|
RtkDACFreeMngtAdpt(
|
|
IN PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt
|
|
){
|
|
#if !DAC_STATIC_ALLOC
|
|
RtlMfree((u8 *)pSalDACMngtAdpt->pUserCB->pTXCB, (sizeof(SAL_DAC_USERCB_ADPT)*SAL_DAC_USER_CB_NUM));
|
|
RtlMfree((u8 *)pSalDACMngtAdpt->pIrqGdmaHnd, sizeof(IRQ_HANDLE));
|
|
RtlMfree((u8 *)pSalDACMngtAdpt->pHalGdmaOp, sizeof(HAL_GDMA_OP));
|
|
RtlMfree((u8 *)pSalDACMngtAdpt->pHalGdmaAdp, sizeof(HAL_GDMA_ADAPTER));
|
|
RtlMfree((u8 *)pSalDACMngtAdpt->pDMAConf, sizeof(SAL_DAC_DMA_USER_DEF));
|
|
RtlMfree((u8 *)pSalDACMngtAdpt->pUserCB, sizeof(SAL_DAC_USER_CB));
|
|
RtlMfree((u8 *)pSalDACMngtAdpt->pIrqHnd, sizeof(IRQ_HANDLE));
|
|
RtlMfree((u8 *)pSalDACMngtAdpt->pHalOp, sizeof(HAL_DAC_OP));
|
|
RtlMfree((u8 *)pSalDACMngtAdpt->pHalInitDat, sizeof(HAL_DAC_INIT_DAT));
|
|
RtlMfree((u8 *)pSalDACMngtAdpt->pSalHndPriv, sizeof(SAL_DAC_HND_PRIV));
|
|
RtlMfree((u8 *)pSalDACMngtAdpt, sizeof(SAL_DAC_MNGT_ADPT));
|
|
#else
|
|
;
|
|
#endif
|
|
|
|
return _EXIT_SUCCESS;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//Function Name:
|
|
// I2CISRHandle
|
|
//
|
|
// Description:
|
|
// I2C Interrupt Service Routine.
|
|
// According to the input pointer to SAL_I2C_HND, all the rest pointers will be
|
|
// found and be used to the rest part of this servie routine.
|
|
// The following types of interrupt will be taken care:
|
|
// - General Call (providing General Call Callback). Slave receives a general call.
|
|
// - STOP Bit (NOT providing General Call Callback)
|
|
// - START Bit (NOTproviding General Call Callback)
|
|
// - I2C Activity (NOTproviding General Call Callback)
|
|
// - RX Done (providing Error Callback). The slave transmitter does NOT
|
|
// receive a proper NACK for the end of whole transfer.
|
|
// - TX Abort (providing Error Call Callback). The Master/Slave
|
|
// transmitting is terminated.
|
|
// - RD Req (providing TX and TXC Callback). Slave gets a Read Request
|
|
// and starts a slave-transmitter operation. The slave transmit
|
|
// data will be written into slave TX FIFO from user data buffer.
|
|
// - TX Empty (providing TX and TXC Callback). Master TX FIFO is empty.
|
|
// The user transmit data will be written into master TX FIFO
|
|
// from user data buffer.
|
|
// - TX Over (providing Error Callback). Master TX FIFO is Overflow.
|
|
// - RX Full (providing RX and RXC Callback). Master/Slave RX FIFO contains
|
|
// data. And the received data will be put into Master/Slave user
|
|
// receive data buffer.
|
|
// - RX Over (providing Error Callback). Master/Slave RX FIFO is Overflow.
|
|
// - RX Under (providing Error Callback). Master/Slave RX FIFO is Underflow.
|
|
//
|
|
// Arguments:
|
|
// [in] VOID *Data -
|
|
// I2C SAL handle
|
|
//
|
|
// Return:
|
|
// NA
|
|
//
|
|
// Note:
|
|
// NA
|
|
//
|
|
// See Also:
|
|
// NA
|
|
//
|
|
// Author:
|
|
// By Jason Deng, 2014-04-02.
|
|
//
|
|
//----------------------------------------------------------------------------------------------------
|
|
VOID
|
|
DACISRHandle(
|
|
IN VOID *Data
|
|
){
|
|
#ifdef CONFIG_DEBUG_LOG_DAC_HAL
|
|
PSAL_DAC_HND pSalDACHND = (PSAL_DAC_HND) Data;
|
|
PSAL_DAC_HND_PRIV pSalDACHNDPriv = NULL;
|
|
PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL;
|
|
PHAL_DAC_INIT_DAT pHalDACInitDat = NULL;
|
|
PHAL_DAC_OP pHalDACOP = NULL;
|
|
PSAL_DAC_USER_CB pSalDACUserCB = NULL;
|
|
u8 DACIrqIdx;
|
|
|
|
/* To get the SAL_I2C_MNGT_ADPT pointer, and parse the rest pointers */
|
|
pSalDACHNDPriv = CONTAINER_OF(pSalDACHND, SAL_DAC_HND_PRIV, SalDACHndPriv);
|
|
pSalDACMngtAdpt = CONTAINER_OF(pSalDACHNDPriv->ppSalDACHnd, SAL_DAC_MNGT_ADPT, pSalHndPriv);
|
|
pHalDACInitDat = pSalDACMngtAdpt->pHalInitDat;
|
|
pHalDACOP = pSalDACMngtAdpt->pHalOp;
|
|
DACIrqIdx = pHalDACInitDat->DACIdx;
|
|
pSalDACUserCB = pSalDACHND->pUserCB;
|
|
|
|
DBG_DAC_INFO("DAC INTR STS:%x\n",pHalDACOP->HalDACReadReg(pHalDACInitDat, REG_DAC_INTR_STS));
|
|
if ((pHalDACOP->HalDACReadReg(pHalDACInitDat, REG_DAC_INTR_STS)) & BIT_DAC_FIFO_STOP_ST){
|
|
pHalDACInitDat->DACEn = DAC_DISABLE;
|
|
pHalDACOP->HalDACEnable((void *)pHalDACInitDat);
|
|
}
|
|
#else
|
|
/* To reduce warning */
|
|
PSAL_DAC_HND pSalDACHND = (PSAL_DAC_HND) Data;
|
|
PSAL_DAC_HND_PRIV pSalDACHNDPriv = NULL;
|
|
PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL;
|
|
PHAL_DAC_INIT_DAT pHalDACInitDat = NULL;
|
|
PHAL_DAC_OP pHalDACOP = NULL;
|
|
|
|
|
|
|
|
/* To get the SAL_I2C_MNGT_ADPT pointer, and parse the rest pointers */
|
|
pSalDACHNDPriv = CONTAINER_OF(pSalDACHND, SAL_DAC_HND_PRIV, SalDACHndPriv);
|
|
pSalDACMngtAdpt = CONTAINER_OF(pSalDACHNDPriv->ppSalDACHnd, SAL_DAC_MNGT_ADPT, pSalHndPriv);
|
|
pHalDACInitDat = pSalDACMngtAdpt->pHalInitDat;
|
|
pHalDACOP = pSalDACMngtAdpt->pHalOp;
|
|
|
|
|
|
pHalDACOP->HalDACReadReg(pHalDACInitDat, REG_DAC_INTR_STS);
|
|
#endif
|
|
}
|
|
|
|
VOID
|
|
DACGDMAISRHandle(
|
|
IN VOID *Data
|
|
){
|
|
|
|
PSAL_DAC_HND pSalDACHND = (PSAL_DAC_HND) Data;
|
|
PSAL_DAC_HND_PRIV pSalDACHNDPriv = NULL;
|
|
PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL;
|
|
|
|
PHAL_GDMA_ADAPTER pHalDACGdmaAdapter = NULL;
|
|
PHAL_GDMA_OP pHalDACGdmaOp = NULL;
|
|
PSAL_DAC_USER_CB pSalDACUserCB = NULL;
|
|
|
|
u8 IsrTypeMap = 0;
|
|
DBG_8195A_DAC_LVL(HAL_DAC_LVL,"%s\n",__func__);
|
|
|
|
|
|
pSalDACHNDPriv = CONTAINER_OF(pSalDACHND, SAL_DAC_HND_PRIV, SalDACHndPriv);
|
|
pSalDACMngtAdpt = CONTAINER_OF(pSalDACHNDPriv->ppSalDACHnd, SAL_DAC_MNGT_ADPT, pSalHndPriv);
|
|
|
|
pHalDACGdmaAdapter = pSalDACMngtAdpt->pHalGdmaAdp;
|
|
pHalDACGdmaOp = pSalDACMngtAdpt->pHalGdmaOp;
|
|
pSalDACUserCB = pSalDACMngtAdpt->pUserCB;
|
|
|
|
pSalDACMngtAdpt->pHalGdmaOpInit(pHalDACGdmaOp);
|
|
|
|
if ((pHalDACGdmaAdapter->MaxMuliBlock) == pHalDACGdmaAdapter->MuliBlockCunt+1) {
|
|
pHalDACGdmaOp->HalGdmaChCleanAutoSrc(pHalDACGdmaAdapter);
|
|
pHalDACGdmaOp->HalGdmaChDis(pHalDACGdmaAdapter);
|
|
pSalDACHND->DevSts = DAC_STS_IDLE;
|
|
if (pSalDACUserCB->pDMATXCCB->USERCB != NULL)
|
|
{
|
|
pSalDACUserCB->pDMATXCCB->USERCB((void*)pSalDACUserCB->pDMATXCCB->USERData);
|
|
}
|
|
}
|
|
else {
|
|
//pHalDACGdmaOp->HalGdmaChCleanAutoSrc(pHalDACGdmaAdapter);
|
|
pSalDACHND->DevSts = DAC_STS_TX_ING;
|
|
|
|
if (pSalDACUserCB->pDMATXCB->USERCB != NULL){
|
|
pSalDACUserCB->pDMATXCB->USERCB((void*)pSalDACUserCB->pDMATXCB->USERData);}
|
|
}
|
|
|
|
//3 Clear Pending ISR
|
|
IsrTypeMap = pHalDACGdmaOp->HalGdmaChIsrClean((VOID*)pHalDACGdmaAdapter);
|
|
|
|
//3 Maintain Block Count
|
|
if (IsrTypeMap & BlockType) {
|
|
pHalDACGdmaAdapter->MuliBlockCunt++;
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
DACGDMALLPISRHandle(
|
|
IN VOID *Data
|
|
){
|
|
PSAL_DAC_HND pSalDACHND = (PSAL_DAC_HND) Data;
|
|
PSAL_DAC_HND_PRIV pSalDACHNDPriv = NULL;
|
|
PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL;
|
|
|
|
PHAL_GDMA_ADAPTER pHalDACGdmaAdapter = NULL;
|
|
PHAL_GDMA_OP pHalDACGdmaOp = NULL;
|
|
|
|
u8 IsrTypeMap;
|
|
|
|
pSalDACHNDPriv = CONTAINER_OF(pSalDACHND, SAL_DAC_HND_PRIV, SalDACHndPriv);
|
|
pSalDACMngtAdpt = CONTAINER_OF(pSalDACHNDPriv->ppSalDACHnd, SAL_DAC_MNGT_ADPT, pSalHndPriv);
|
|
|
|
pHalDACGdmaAdapter = pSalDACMngtAdpt->pHalGdmaAdp;
|
|
pHalDACGdmaOp = pSalDACMngtAdpt->pHalGdmaOp;
|
|
|
|
|
|
pSalDACMngtAdpt->pHalGdmaOpInit(pHalDACGdmaOp);
|
|
#if 0
|
|
PGDMA_ADAPTER pGdmaAdapte = (PGDMA_ADAPTER) Data;
|
|
PHAL_GDMA_ADAPTER pHalGdmaAdapter = pGdmaAdapte->pHalGdmaAdapter;
|
|
PGDMA_CH_LLI_ELE pGdmaChLliEle;
|
|
struct GDMA_CH_LLI *pGdmaChLli = pHalGdmaAdapter->pLlix;
|
|
struct BLOCK_SIZE_LIST *pBlockSizeList = pHalGdmaAdapter->pBlockSizeList;
|
|
u32 TotalBlockSize = 0;
|
|
u8 IsrTypeMap, BlockIndex;
|
|
u8 *pSrc = NULL, *pDst = NULL;
|
|
DBG_8195A_DMA("Enter Gdma0 Channel 5 ISr =====>\n");
|
|
#endif
|
|
|
|
|
|
|
|
if ((pHalDACGdmaAdapter->MaxMuliBlock) == pHalDACGdmaAdapter->MuliBlockCunt) {
|
|
//HalGdmaOp.HalGdmaChCleanAutoSrc(pHalGdmaAdapter);
|
|
//DAC0_FCTRL(OFF);
|
|
|
|
//HalGdmaOp.HalGdmaChCleanAutoDst(pHalGdmaAdapter);
|
|
pHalDACGdmaOp->HalGdmaChDis(pHalDACGdmaAdapter);
|
|
|
|
DBG_8195A("dma done\n");
|
|
}
|
|
|
|
|
|
IsrTypeMap = pHalDACGdmaOp->HalGdmaChIsrClean((VOID*)pHalDACGdmaAdapter);
|
|
|
|
if (IsrTypeMap & BlockType) {
|
|
pHalDACGdmaAdapter->MuliBlockCunt++;
|
|
}
|
|
}
|
|
|
|
static RTK_STATUS
|
|
RtkDACPinMuxInit(
|
|
IN PSAL_DAC_HND pSalDACHND
|
|
){
|
|
u32 DACLocalTemp;
|
|
|
|
/* Check the I2C index first */
|
|
if (RtkDACIdxChk(pSalDACHND->DevNum))
|
|
return _EXIT_FAILURE;
|
|
|
|
DACLocalTemp = HAL_READ32(SYSTEM_CTRL_BASE, REG_SYS_SYSPLL_CTRL2);
|
|
DACLocalTemp |= BIT26;
|
|
|
|
/* To release DAC delta sigma clock gating */
|
|
HAL_WRITE32(SYSTEM_CTRL_BASE,REG_SYS_SYSPLL_CTRL2,DACLocalTemp);
|
|
|
|
switch (pSalDACHND->DevNum){
|
|
#if DAC0_USED
|
|
case DAC0_SEL:
|
|
{
|
|
/* Turn on DAC active clock */
|
|
ACTCK_DAC_CCTRL(ON);
|
|
|
|
/* Enable DAC0 module */
|
|
DAC0_FCTRL(ON);
|
|
break;
|
|
}
|
|
#endif
|
|
#if DAC1_USED
|
|
case DAC1_SEL:
|
|
{
|
|
/* Turn on DAC active clock */
|
|
ACTCK_DAC_CCTRL(ON);
|
|
|
|
/* Enable DAC1 module */
|
|
DAC1_FCTRL(ON);
|
|
break;
|
|
}
|
|
#endif
|
|
default:
|
|
return _EXIT_FAILURE;
|
|
}
|
|
|
|
return _EXIT_SUCCESS;
|
|
}
|
|
|
|
static RTK_STATUS
|
|
RtkDACPinMuxDeInit(
|
|
IN PSAL_DAC_HND pSalDACHND
|
|
){
|
|
|
|
u32 DACLocalTemp;
|
|
|
|
/* Check the I2C index first */
|
|
if (RtkDACIdxChk(pSalDACHND->DevNum))
|
|
return _EXIT_FAILURE;
|
|
|
|
switch (pSalDACHND->DevNum){
|
|
#if DAC0_USED
|
|
case DAC0_SEL:
|
|
{
|
|
/* Turn on DAC active clock */
|
|
ACTCK_DAC_CCTRL(OFF);
|
|
|
|
/* Enable DAC0 module */
|
|
DAC0_FCTRL(OFF);
|
|
break;
|
|
}
|
|
#endif
|
|
#if DAC1_USED
|
|
case DAC1_SEL:
|
|
{
|
|
/* Turn on DAC active clock */
|
|
ACTCK_DAC_CCTRL(OFF);
|
|
|
|
/* Enable DAC1 module */
|
|
DAC1_FCTRL(OFF);
|
|
break;
|
|
}
|
|
#endif
|
|
default:
|
|
return _EXIT_FAILURE;
|
|
}
|
|
|
|
|
|
DACLocalTemp = HAL_READ32(SYSTEM_CTRL_BASE, REG_SYS_SYSPLL_CTRL2);
|
|
DACLocalTemp &= (~BIT26);
|
|
|
|
/* To release DAC delta sigma clock gating */
|
|
HAL_WRITE32(SYSTEM_CTRL_BASE,REG_SYS_SYSPLL_CTRL2,DACLocalTemp);
|
|
|
|
return _EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
#if DAC_INTR_OP_TYPE
|
|
//---------------------------------------------------------------------------------------------------
|
|
//Function Name:
|
|
// RtkI2CIrqInit
|
|
//
|
|
// Description:
|
|
// I2C interrupt initialization function.
|
|
// For I2C interrupt operation mode, I2C module MUST register itself to the platform
|
|
// by providing the interrupt handler which contains interrupt input data (arguments),
|
|
// interrupt service routine, interrupt number, interrupt priority. And then the interrupt
|
|
// should be enabled.
|
|
//
|
|
// Arguments:
|
|
// [in] VOID *Data -
|
|
// I2C SAL handle
|
|
//
|
|
// Return:
|
|
// The status of the I2C interrupt initialization process.
|
|
// _EXIT_SUCCESS if the RtkI2CIrqInit succeeded.
|
|
// _EXIT_FAILURE if the RtkI2CIrqInit failed.
|
|
//
|
|
// Note:
|
|
// NA
|
|
//
|
|
// See Also:
|
|
// NA
|
|
//
|
|
// Author:
|
|
// By Jason Deng, 2014-04-03.
|
|
//
|
|
//----------------------------------------------------------------------------------------------------
|
|
static RTK_STATUS
|
|
RtkDACIrqInit(
|
|
IN PSAL_DAC_HND pSalDACHND
|
|
){
|
|
PSAL_DAC_HND_PRIV pSalDACHNDPriv = NULL;
|
|
PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL;
|
|
PIRQ_HANDLE pIrqHandle = NULL;
|
|
|
|
/* To Get the SAL_I2C_MNGT_ADPT Pointer */
|
|
pSalDACHNDPriv = CONTAINER_OF(pSalDACHND, SAL_DAC_HND_PRIV, SalDACHndPriv);
|
|
pSalDACMngtAdpt = CONTAINER_OF(pSalDACHNDPriv->ppSalDACHnd, SAL_DAC_MNGT_ADPT, pSalHndPriv);
|
|
pIrqHandle = pSalDACMngtAdpt->pIrqHnd;
|
|
|
|
if (RtkDACIdxChk(pSalDACHND->DevNum))
|
|
return _EXIT_FAILURE;
|
|
|
|
switch (pSalDACHND->DevNum){
|
|
#if DAC0_USED
|
|
case DAC0_SEL:
|
|
{
|
|
pIrqHandle->Data = (u32) (pSalDACHND);
|
|
pIrqHandle->IrqNum = DAC0_IRQ;
|
|
pIrqHandle->IrqFun = (IRQ_FUN) pSalDACMngtAdpt->pSalIrqFunc;
|
|
pIrqHandle->Priority = 5;
|
|
InterruptRegister(pIrqHandle);
|
|
InterruptEn(pIrqHandle);
|
|
break;
|
|
}
|
|
#endif
|
|
#if DAC1_USED
|
|
case DAC1_SEL:
|
|
{
|
|
pIrqHandle->Data = (u32) (pSalDACHND);
|
|
pIrqHandle->IrqNum = DAC1_IRQ;
|
|
pIrqHandle->IrqFun = (IRQ_FUN) pSalDACMngtAdpt->pSalIrqFunc;;
|
|
pIrqHandle->Priority = 5;
|
|
InterruptRegister(pIrqHandle);
|
|
InterruptEn(pIrqHandle);
|
|
break;
|
|
}
|
|
#endif
|
|
default:
|
|
return _EXIT_FAILURE;
|
|
}
|
|
|
|
|
|
|
|
return _EXIT_SUCCESS;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//Function Name:
|
|
// RtkI2CIrqDeInit
|
|
//
|
|
// Description:
|
|
// I2C interrupt de-initialization function.
|
|
// According to the given I2C device number, the I2C interrupt will be unreigster
|
|
// from the platform and the relative interrupt handler will be cleared.
|
|
//
|
|
// Arguments:
|
|
// [in] VOID *Data -
|
|
// I2C SAL handle
|
|
//
|
|
// Return:
|
|
// The status of the I2C interrupt de-initialization process.
|
|
// _EXIT_SUCCESS if the RtkI2CIrqDeInit succeeded.
|
|
// _EXIT_FAILURE if the RtkI2CIrqDeInit failed.
|
|
//
|
|
// Note:
|
|
// NA
|
|
//
|
|
// See Also:
|
|
// NA
|
|
//
|
|
// Author:
|
|
// By Jason Deng, 2014-04-03.
|
|
//
|
|
//----------------------------------------------------------------------------------------------------
|
|
static RTK_STATUS
|
|
RtkDACIrqDeInit(
|
|
IN PSAL_DAC_HND pSalDACHND
|
|
){
|
|
PSAL_DAC_HND_PRIV pSalDACHNDPriv = NULL;
|
|
PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL;
|
|
PIRQ_HANDLE pIrqHandle = NULL;
|
|
|
|
/*To Get the SAL_I2C_MNGT_ADPT Pointer*/
|
|
pSalDACHNDPriv = CONTAINER_OF(pSalDACHND, SAL_DAC_HND_PRIV, SalDACHndPriv);
|
|
pSalDACMngtAdpt = CONTAINER_OF(pSalDACHNDPriv->ppSalDACHnd, SAL_DAC_MNGT_ADPT, pSalHndPriv);
|
|
pIrqHandle = pSalDACMngtAdpt->pIrqHnd;
|
|
|
|
if (RtkDACIdxChk(pSalDACHND->DevNum))
|
|
return _EXIT_FAILURE;
|
|
|
|
InterruptUnRegister(pIrqHandle);
|
|
return _EXIT_SUCCESS;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
#if DAC_DMA_OP_TYPE
|
|
const u16 DACDmaChNo[10] = {GdmaNoCh ,GdmaCh0,
|
|
GdmaCh1 ,GdmaCh2,
|
|
GdmaCh3 ,GdmaCh4,
|
|
GdmaCh5 ,GdmaCh6,
|
|
GdmaCh7 ,GdmaAllCh};
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//Function Name:
|
|
// RtkI2CIrqInit
|
|
//
|
|
// Description:
|
|
// I2C interrupt initialization function.
|
|
// For I2C interrupt operation mode, I2C module MUST register itself to the platform
|
|
// by providing the interrupt handler which contains interrupt input data (arguments),
|
|
// interrupt service routine, interrupt number, interrupt priority. And then the interrupt
|
|
// should be enabled.
|
|
//
|
|
// Arguments:
|
|
// [in] VOID *Data -
|
|
// I2C SAL handle
|
|
//
|
|
// Return:
|
|
// The status of the I2C interrupt initialization process.
|
|
// _EXIT_SUCCESS if the RtkI2CIrqInit succeeded.
|
|
// _EXIT_FAILURE if the RtkI2CIrqInit failed.
|
|
//
|
|
// Note:
|
|
// NA
|
|
//
|
|
// See Also:
|
|
// NA
|
|
//
|
|
// Author:
|
|
// By Jason Deng, 2014-04-03.
|
|
//
|
|
//----------------------------------------------------------------------------------------------------
|
|
static RTK_STATUS
|
|
RtkDACDMAInit(
|
|
IN PSAL_DAC_HND pSalDACHND
|
|
){
|
|
PSAL_DAC_HND_PRIV pSalDACHNDPriv = NULL;
|
|
PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL;
|
|
PHAL_GDMA_ADAPTER pHALDACGdmaAdpt = NULL;
|
|
PHAL_GDMA_OP pHALDACGdmaOp = NULL;
|
|
PIRQ_HANDLE pIrqHandleDACGdma = NULL;
|
|
PSAL_DAC_DMA_USER_DEF pSalDACDmaUserDef = NULL;
|
|
|
|
|
|
|
|
/* To Get the SAL_I2C_MNGT_ADPT Pointer */
|
|
pSalDACHNDPriv = CONTAINER_OF(pSalDACHND, SAL_DAC_HND_PRIV, SalDACHndPriv);
|
|
pSalDACMngtAdpt = CONTAINER_OF(pSalDACHNDPriv->ppSalDACHnd, SAL_DAC_MNGT_ADPT, pSalHndPriv);
|
|
|
|
pHALDACGdmaAdpt = pSalDACMngtAdpt->pHalGdmaAdp;
|
|
pHALDACGdmaOp = pSalDACMngtAdpt->pHalGdmaOp;
|
|
pIrqHandleDACGdma = pSalDACMngtAdpt->pIrqGdmaHnd;
|
|
pSalDACDmaUserDef = pSalDACHND->pDMAConf;
|
|
|
|
if (RtkDACIdxChk(pSalDACHND->DevNum))
|
|
return _EXIT_FAILURE;
|
|
|
|
if (pSalDACHND->DACInType == DAC_INPUT_SINGLE_WR)
|
|
return _EXIT_SUCCESS;
|
|
|
|
/* GDMA operation initialization */
|
|
//HalGdmaOpInit(pHalI2CGdmaOp);
|
|
_memset((void *)pHALDACGdmaAdpt, 0, sizeof(HAL_GDMA_ADAPTER));
|
|
pSalDACMngtAdpt->pHalGdmaOpInit(pHALDACGdmaOp);
|
|
pHALDACGdmaOp->HalGdamChInit((VOID*)(pHALDACGdmaAdpt));
|
|
|
|
|
|
|
|
pHALDACGdmaAdpt->GdmaIndex = pSalDACHND->DevNum;
|
|
pHALDACGdmaAdpt->GdmaCtl.IntEn = 1;
|
|
pHALDACGdmaAdpt->ChNum = pSalDACDmaUserDef->TxChNo;
|
|
|
|
pHALDACGdmaAdpt->ChEn = DACDmaChNo[pHALDACGdmaAdpt->ChNum+1];
|
|
pHALDACGdmaAdpt->IsrCtrl = ENABLE;
|
|
pHALDACGdmaAdpt->GdmaOnOff = ON;
|
|
|
|
|
|
/* GDMA initialization */
|
|
/* Enable the whole GDMA module first */
|
|
if (pHALDACGdmaAdpt->GdmaIndex == 0) {
|
|
ACTCK_GDMA0_CCTRL(ON);
|
|
SLPCK_GDMA0_CCTRL(ON);
|
|
GDMA0_FCTRL(ON);
|
|
}
|
|
else {
|
|
ACTCK_GDMA1_CCTRL(ON);
|
|
SLPCK_GDMA1_CCTRL(ON);
|
|
GDMA1_FCTRL(ON);
|
|
}
|
|
|
|
if (pSalDACHND->DACInType == DAC_INPUT_DMA_ONEBLK) {
|
|
//DAC TX DMA
|
|
pHALDACGdmaAdpt->GdmaCtl.SrcTrWidth = pSalDACDmaUserDef->TxDatSrcWdth;
|
|
pHALDACGdmaAdpt->GdmaCtl.DstTrWidth = pSalDACDmaUserDef->TxDatDstWdth;
|
|
pHALDACGdmaAdpt->GdmaCtl.SrcMsize = pSalDACDmaUserDef->TxDatSrcBstSz;
|
|
pHALDACGdmaAdpt->GdmaCtl.DestMsize = pSalDACDmaUserDef->TxDatDstBstSz;
|
|
|
|
pHALDACGdmaAdpt->GdmaCtl.Sinc = IncType;
|
|
pHALDACGdmaAdpt->GdmaCtl.Dinc = NoChange;
|
|
|
|
pHALDACGdmaAdpt->GdmaCtl.Done = 1;
|
|
pHALDACGdmaAdpt->GdmaCtl.TtFc = 0x01;
|
|
|
|
pHALDACGdmaAdpt->GdmaCfg.DestPer = 13;
|
|
pHALDACGdmaAdpt->GdmaCfg.ReloadSrc = 1;
|
|
|
|
pHALDACGdmaAdpt->MuliBlockCunt = 1;
|
|
pHALDACGdmaAdpt->MaxMuliBlock = pSalDACHND->pDMAConf->MaxMultiBlk;
|
|
|
|
pHALDACGdmaAdpt->GdmaIsrType = (BlockType|TransferType|ErrType);
|
|
|
|
|
|
pHALDACGdmaAdpt->TestItem = 3;
|
|
|
|
|
|
//pSalDACMngtAdpt->pSalDMAIrqFunc = &DACGDMAISRHandle;
|
|
}
|
|
else if (pSalDACHND->DACInType == DAC_INPUT_DMA_LLP) {
|
|
//DAC TX DMA
|
|
pHALDACGdmaAdpt->GdmaCtl.SrcTrWidth = pSalDACDmaUserDef->TxDatSrcWdth;
|
|
pHALDACGdmaAdpt->GdmaCtl.DstTrWidth = pSalDACDmaUserDef->TxDatDstWdth;
|
|
pHALDACGdmaAdpt->GdmaCtl.SrcMsize = pSalDACDmaUserDef->TxDatSrcBstSz;
|
|
pHALDACGdmaAdpt->GdmaCtl.DestMsize = pSalDACDmaUserDef->TxDatDstBstSz;
|
|
|
|
pHALDACGdmaAdpt->GdmaCtl.Dinc = NoChange;
|
|
|
|
pHALDACGdmaAdpt->GdmaCtl.Done = 1;
|
|
pHALDACGdmaAdpt->GdmaCtl.TtFc = 0x01;
|
|
pHALDACGdmaAdpt->GdmaCtl.LlpSrcEn = 1;
|
|
|
|
pHALDACGdmaAdpt->GdmaCfg.DestPer = 13;
|
|
|
|
pHALDACGdmaAdpt->GdmaIsrType = (BlockType|ErrType);
|
|
|
|
/* Enable LLP control */
|
|
pHALDACGdmaAdpt->Llpctrl = pSalDACDmaUserDef->LlpCtrl;
|
|
|
|
pHALDACGdmaAdpt->MuliBlockCunt = 1;
|
|
pHALDACGdmaAdpt->MaxMuliBlock = pSalDACDmaUserDef->MaxMultiBlk;
|
|
|
|
pHALDACGdmaAdpt->TestItem = 9;
|
|
|
|
//pSalDACMngtAdpt->pSalDMAIrqFunc = &DACGDMALLPISRHandle;
|
|
}
|
|
|
|
|
|
/* GDMA interrupt register */
|
|
pIrqHandleDACGdma->Data = (u32) (pSalDACHND);
|
|
pIrqHandleDACGdma->IrqNum = GDMA0_CHANNEL0_IRQ + pHALDACGdmaAdpt->ChNum +
|
|
((pHALDACGdmaAdpt->GdmaIndex)*6);
|
|
pIrqHandleDACGdma->IrqFun = (IRQ_FUN) pSalDACMngtAdpt->pSalDMAIrqFunc;
|
|
pIrqHandleDACGdma->Priority = 2;
|
|
InterruptRegister(pIrqHandleDACGdma);
|
|
InterruptEn(pIrqHandleDACGdma);
|
|
|
|
|
|
pHALDACGdmaOp->HalGdmaOnOff((VOID*)pHALDACGdmaAdpt);
|
|
pHALDACGdmaOp->HalGdmaChIsrEnAndDis((VOID*)pHALDACGdmaAdpt);
|
|
|
|
#if 0
|
|
/* Enable GDMA according to the DMA type */
|
|
if (pSalDACHND->DACInType == DAC_INPUT_DMA_ONEBLK) {
|
|
pHALDACGdmaOp->HalGdmaChSeting((VOID*)pHALDACGdmaAdpt);
|
|
}
|
|
else if (pSalDACHND->DACInType == DAC_INPUT_DMA_LLP){
|
|
//pHALDACGdmaOp->HalGdmaChBlockSeting((VOID*)(pHALDACGdmaAdpt));
|
|
}
|
|
#endif
|
|
return _EXIT_SUCCESS;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//Function Name:
|
|
// RtkI2CIrqDeInit
|
|
//
|
|
// Description:
|
|
// I2C interrupt de-initialization function.
|
|
// According to the given I2C device number, the I2C interrupt will be unreigster
|
|
// from the platform and the relative interrupt handler will be cleared.
|
|
//
|
|
// Arguments:
|
|
// [in] VOID *Data -
|
|
// I2C SAL handle
|
|
//
|
|
// Return:
|
|
// The status of the I2C interrupt de-initialization process.
|
|
// _EXIT_SUCCESS if the RtkI2CIrqDeInit succeeded.
|
|
// _EXIT_FAILURE if the RtkI2CIrqDeInit failed.
|
|
//
|
|
// Note:
|
|
// NA
|
|
//
|
|
// See Also:
|
|
// NA
|
|
//
|
|
// Author:
|
|
// By Jason Deng, 2014-04-03.
|
|
//
|
|
//----------------------------------------------------------------------------------------------------
|
|
static RTK_STATUS
|
|
RtkDACDMADeInit(
|
|
IN PSAL_DAC_HND pSalDACHND
|
|
){
|
|
PSAL_DAC_HND_PRIV pSalDACHNDPriv = NULL;
|
|
PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL;
|
|
|
|
PHAL_GDMA_ADAPTER pHALDACGdmaAdpt = NULL;
|
|
PHAL_GDMA_OP pHALDACGdmaOp = NULL;
|
|
PIRQ_HANDLE pIrqHandleDACGdma = NULL;
|
|
|
|
/*To Get the SAL_I2C_MNGT_ADPT Pointer*/
|
|
pSalDACHNDPriv = CONTAINER_OF(pSalDACHND, SAL_DAC_HND_PRIV, SalDACHndPriv);
|
|
pSalDACMngtAdpt = CONTAINER_OF(pSalDACHNDPriv->ppSalDACHnd, SAL_DAC_MNGT_ADPT, pSalHndPriv);
|
|
|
|
pHALDACGdmaAdpt = pSalDACMngtAdpt->pHalGdmaAdp;
|
|
pHALDACGdmaOp = pSalDACMngtAdpt->pHalGdmaOp;
|
|
pIrqHandleDACGdma = pSalDACMngtAdpt->pIrqGdmaHnd;
|
|
|
|
if (RtkDACIdxChk(pSalDACHND->DevNum))
|
|
return _EXIT_FAILURE;
|
|
|
|
HalGdmaOpInit(pHALDACGdmaOp);
|
|
|
|
pHALDACGdmaAdpt->IsrCtrl = DISABLE;
|
|
pHALDACGdmaOp->HalGdmaChIsrEnAndDis((VOID*)pHALDACGdmaAdpt);
|
|
pHALDACGdmaOp->HalGdmaChIsrClean((VOID*)pHALDACGdmaAdpt);
|
|
pHALDACGdmaOp->HalGdmaChDis((VOID*)pHALDACGdmaAdpt);
|
|
|
|
InterruptUnRegister(pIrqHandleDACGdma);
|
|
#if 0
|
|
_memset((void *)pIrqHandleDACGdma , 0, sizeof(IRQ_HANDLE));
|
|
_memset((void *)pHALDACGdmaOp , 0, sizeof(HAL_GDMA_OP));
|
|
_memset((void *)pHALDACGdmaAdpt , 0, sizeof(HAL_GDMA_ADAPTER));
|
|
#endif
|
|
return _EXIT_SUCCESS;
|
|
}
|
|
|
|
#endif
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//Function Name:
|
|
// RtkI2CInit
|
|
//
|
|
// Description:
|
|
// According to the given I2C index, the related SAL_I2C_MNGT_ADPT pointer used
|
|
// for retrieving each I2C data sturcture pointer will be reversely parsed first.
|
|
// Then, initializing I2C HAL operation, initializing I2C interrupt (if needed),
|
|
// initializing I2C DMA (if needed) and initializing I2C pinmux will be done.
|
|
// User specified I2C configuration will be assigned to I2C initial data structure
|
|
// (PHAL_I2C_INIT_DAT pHalI2CInitDat). I2C HAL initialization is executed after
|
|
// all the configuration data taken.
|
|
// In the end, I2C module is enabled as a final step of the whole initialization.
|
|
// For a slave ack General Call support, an additional step may be followed after
|
|
// the above steps.
|
|
//
|
|
// Arguments:
|
|
// [in] VOID *Data -
|
|
// I2C SAL handle
|
|
//
|
|
// Return:
|
|
// The status of the I2C initialization process.
|
|
// _EXIT_SUCCESS if the RtkI2CInit succeeded.
|
|
// _EXIT_FAILURE if the RtkI2CInit failed.
|
|
//
|
|
// Note:
|
|
// NA
|
|
//
|
|
// See Also:
|
|
// NA
|
|
//
|
|
// Author:
|
|
// By Jason Deng, 2014-04-03.
|
|
//
|
|
//----------------------------------------------------------------------------------------------------
|
|
RTK_STATUS
|
|
RtkDACInit(
|
|
IN VOID *Data
|
|
){
|
|
PSAL_DAC_HND pSalDACHND = (PSAL_DAC_HND) Data;
|
|
PSAL_DAC_HND_PRIV pSalDACHNDPriv = NULL;
|
|
PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL;
|
|
//PHAL_DAC_INIT_DAT pHalDACInitDat = NULL;
|
|
PHAL_DAC_OP pHalDACOP = NULL;
|
|
|
|
u32 DacTemp;
|
|
|
|
/* To Get the SAL_I2C_MNGT_ADPT Pointer */
|
|
pSalDACHNDPriv = CONTAINER_OF(pSalDACHND, SAL_DAC_HND_PRIV, SalDACHndPriv);
|
|
pSalDACMngtAdpt = CONTAINER_OF(pSalDACHNDPriv->ppSalDACHnd, SAL_DAC_MNGT_ADPT, pSalHndPriv);
|
|
|
|
//pHalDACInitDat = pSalDACMngtAdpt->pHalInitDat;
|
|
pHalDACOP = pSalDACMngtAdpt->pHalOp;
|
|
|
|
/* Check the input I2C index first */
|
|
if (RtkDACIdxChk(pSalDACHND->DevNum))
|
|
return _EXIT_FAILURE;
|
|
|
|
#if 0
|
|
/* Check the input I2C operation type */
|
|
if (RtkI2COpTypeChk(pSalI2CHND))
|
|
return _EXIT_FAILURE;
|
|
#endif
|
|
|
|
/* DAC Initialize HAL Operations */
|
|
HalDACOpInit(pHalDACOP);
|
|
|
|
/* DAC Interrupt Initialization */
|
|
#if DAC_INTR_OP_TYPE
|
|
RtkDACIrqInit(pSalDACHND);
|
|
#endif
|
|
|
|
/* DAC DMA Initialization */
|
|
#if DAC_DMA_OP_TYPE
|
|
RtkDACDMAInit(pSalDACHND);
|
|
#endif
|
|
|
|
|
|
/* DAC Function and Clock Enable*/
|
|
RtkDACPinMuxInit(pSalDACHND);
|
|
|
|
pHalDACOP->HalDACInit(pSalDACHND->pInitDat);
|
|
|
|
#if 1
|
|
HAL_DAC_WRITE32(pSalDACHND->DevNum, REG_DAC_INTR_CTRL,
|
|
(BIT_DAC_FIFO_FULL_EN |
|
|
BIT_DAC_FIFO_OVERFLOW_EN |
|
|
BIT_DAC_FIFO_STOP_EN |
|
|
BIT_DAC__WRITE_ERROR_EN |
|
|
BIT_DAC_DSC_OVERFLOW0_EN |
|
|
BIT_DAC_DSC_OVERFLOW1_EN));
|
|
#else
|
|
HAL_DAC_WRITE32(pSalDACHND->DevNum, REG_DAC_INTR_CTRL,
|
|
(BIT_DAC_FIFO_FULL_EN|
|
|
BIT_DAC_FIFO_OVERFLOW_EN|
|
|
BIT_DAC_FIFO_STOP_EN|
|
|
BIT_DAC__WRITE_ERROR_EN|
|
|
BIT_DAC_DSC_OVERFLOW0_EN|
|
|
BIT_DAC_DSC_OVERFLOW1_EN));
|
|
#endif
|
|
DBG_DAC_INFO("INTR MSK:%x\n", HAL_DAC_READ32(pSalDACHND->DevNum,REG_DAC_INTR_CTRL));
|
|
|
|
|
|
|
|
DacTemp = HAL_DAC_READ32(pSalDACHND->DevNum, REG_DAC_ANAPAR_DA1);
|
|
DacTemp |= (BIT31);
|
|
HAL_DAC_WRITE32(pSalDACHND->DevNum, REG_DAC_ANAPAR_DA1, DacTemp);
|
|
//DBG_DAC_INFO("REG_DAC_ANAPAR_DA1:%08x\n",DacTemp);
|
|
DBG_DAC_INFO("REG_DAC_ANAPAR_DA1:%08x\n",HAL_DAC_READ32(pSalDACHND->DevNum, REG_DAC_ANAPAR_DA1));
|
|
DacTemp = HAL_DAC_READ32(pSalDACHND->DevNum, REG_DAC_CTRL);
|
|
DacTemp |= BIT3;
|
|
HAL_DAC_WRITE32(pSalDACHND->DevNum, REG_DAC_CTRL, DacTemp);
|
|
DBG_DAC_INFO("REG_DAC_CTRL:%08x\n",DacTemp);
|
|
|
|
pSalDACHND->pInitDat->DACEn = DAC_ENABLE;
|
|
pHalDACOP->HalDACEnable(pSalDACHND->pInitDat);
|
|
|
|
/* DAC Device Status Update */
|
|
pSalDACHND->DevSts = DAC_STS_IDLE;
|
|
|
|
return _EXIT_SUCCESS;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//Function Name:
|
|
// RtkI2CInit
|
|
//
|
|
// Description:
|
|
// According to the given I2C index, the related SAL_I2C_MNGT_ADPT pointer used
|
|
// for retrieving each I2C data sturcture pointer will be reversely parsed first.
|
|
// Then, initializing I2C HAL operation, initializing I2C interrupt (if needed),
|
|
// initializing I2C DMA (if needed) and initializing I2C pinmux will be done.
|
|
// User specified I2C configuration will be assigned to I2C initial data structure
|
|
// (PHAL_I2C_INIT_DAT pHalI2CInitDat). I2C HAL initialization is executed after
|
|
// all the configuration data taken.
|
|
// In the end, I2C module is enabled as a final step of the whole initialization.
|
|
// For a slave ack General Call support, an additional step may be followed after
|
|
// the above steps.
|
|
//
|
|
// Arguments:
|
|
// [in] VOID *Data -
|
|
// I2C SAL handle
|
|
//
|
|
// Return:
|
|
// The status of the I2C initialization process.
|
|
// _EXIT_SUCCESS if the RtkI2CInit succeeded.
|
|
// _EXIT_FAILURE if the RtkI2CInit failed.
|
|
//
|
|
// Note:
|
|
// NA
|
|
//
|
|
// See Also:
|
|
// NA
|
|
//
|
|
// Author:
|
|
// By Jason Deng, 2014-04-03.
|
|
//
|
|
//----------------------------------------------------------------------------------------------------
|
|
RTK_STATUS
|
|
RtkDACDeInit(
|
|
IN VOID *Data
|
|
){
|
|
PSAL_DAC_HND pSalDACHND = (PSAL_DAC_HND) Data;
|
|
PSAL_DAC_HND_PRIV pSalDACHNDPriv = NULL;
|
|
PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL;
|
|
PHAL_DAC_INIT_DAT pHalDACInitDat = NULL;
|
|
PHAL_DAC_OP pHalDACOP = NULL;
|
|
|
|
/* To Get the SAL_DAC_MNGT_ADPT Pointer */
|
|
pSalDACHNDPriv = CONTAINER_OF(pSalDACHND, SAL_DAC_HND_PRIV, SalDACHndPriv);
|
|
pSalDACMngtAdpt = CONTAINER_OF(pSalDACHNDPriv->ppSalDACHnd, SAL_DAC_MNGT_ADPT, pSalHndPriv);
|
|
|
|
pHalDACInitDat = pSalDACMngtAdpt->pHalInitDat;
|
|
pHalDACOP = pSalDACMngtAdpt->pHalOp;
|
|
|
|
/* Check the input DAC index first */
|
|
if (RtkDACIdxChk(pSalDACHND->DevNum))
|
|
return _EXIT_FAILURE;
|
|
|
|
{
|
|
/* DAC Initialize HAL Operations */
|
|
HalDACOpInit(pHalDACOP);
|
|
|
|
/* DAC Interrupt Initialization */
|
|
#if DAC_INTR_OP_TYPE
|
|
RtkDACIrqDeInit(pSalDACHND);
|
|
#endif
|
|
|
|
/* DAC DMA Initialization */
|
|
#if DAC_DMA_OP_TYPE
|
|
RtkDACDMADeInit(pSalDACHND);
|
|
#endif
|
|
|
|
pHalDACInitDat->DACEn = DAC_DISABLE;
|
|
pHalDACOP->HalDACEnable(pHalDACInitDat);
|
|
pHalDACOP->HalDACDeInit(pHalDACInitDat);
|
|
|
|
/* DAC Function and Clock Enable*/
|
|
RtkDACPinMuxDeInit(pSalDACHND);
|
|
}
|
|
|
|
return _EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//Function Name:
|
|
// RtkI2CInit
|
|
//
|
|
// Description:
|
|
// According to the given I2C index, the related SAL_I2C_MNGT_ADPT pointer used
|
|
// for retrieving each I2C data sturcture pointer will be reversely parsed first.
|
|
// Then, initializing I2C HAL operation, initializing I2C interrupt (if needed),
|
|
// initializing I2C DMA (if needed) and initializing I2C pinmux will be done.
|
|
// User specified I2C configuration will be assigned to I2C initial data structure
|
|
// (PHAL_I2C_INIT_DAT pHalI2CInitDat). I2C HAL initialization is executed after
|
|
// all the configuration data taken.
|
|
// In the end, I2C module is enabled as a final step of the whole initialization.
|
|
// For a slave ack General Call support, an additional step may be followed after
|
|
// the above steps.
|
|
//
|
|
// Arguments:
|
|
// [in] VOID *Data -
|
|
// I2C SAL handle
|
|
//
|
|
// Return:
|
|
// The status of the I2C initialization process.
|
|
// _EXIT_SUCCESS if the RtkI2CInit succeeded.
|
|
// _EXIT_FAILURE if the RtkI2CInit failed.
|
|
//
|
|
// Note:
|
|
// NA
|
|
//
|
|
// See Also:
|
|
// NA
|
|
//
|
|
// Author:
|
|
// By Jason Deng, 2014-04-03.
|
|
//
|
|
//----------------------------------------------------------------------------------------------------
|
|
RTK_STATUS
|
|
RtkDACSend(
|
|
IN VOID *Data
|
|
){
|
|
PSAL_DAC_HND pSalDACHND = (PSAL_DAC_HND) Data;
|
|
PSAL_DAC_HND_PRIV pSalDACHNDPriv = NULL;
|
|
PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL;
|
|
PHAL_GDMA_ADAPTER pHALDACGdmaAdpt = NULL;
|
|
PHAL_GDMA_OP pHALDACGdmaOp = NULL;
|
|
PSAL_DAC_DMA_USER_DEF pSalDACDmaUserDef = NULL;
|
|
//PIRQ_HANDLE pIrqHandleDACGdma = NULL;
|
|
|
|
/* To Get the SAL_I2C_MNGT_ADPT Pointer */
|
|
pSalDACHNDPriv = CONTAINER_OF(pSalDACHND, SAL_DAC_HND_PRIV, SalDACHndPriv);
|
|
pSalDACMngtAdpt = CONTAINER_OF(pSalDACHNDPriv->ppSalDACHnd, SAL_DAC_MNGT_ADPT, pSalHndPriv);
|
|
|
|
pHALDACGdmaAdpt = pSalDACMngtAdpt->pHalGdmaAdp;
|
|
pHALDACGdmaOp = pSalDACMngtAdpt->pHalGdmaOp;
|
|
pSalDACDmaUserDef = pSalDACMngtAdpt->pDMAConf;
|
|
|
|
switch (pSalDACHND->DACInType) {
|
|
case DAC_INPUT_SINGLE_WR:
|
|
{
|
|
break;
|
|
}
|
|
case DAC_INPUT_DMA_ONEBLK:
|
|
{
|
|
HalGdmaOpInit(pHALDACGdmaOp);
|
|
|
|
pHALDACGdmaAdpt->GdmaCtl.BlockSize = pSalDACHND->pTXBuf->DataLen;
|
|
pHALDACGdmaAdpt->ChSar = (u32)pSalDACHND->pTXBuf->pDataBuf;
|
|
pHALDACGdmaAdpt->ChDar = (u32)(DAC_REG_BASE+(pSalDACHND->DevNum*0x800));
|
|
|
|
DBG_DAC_INFO("src addr:%x\n", pHALDACGdmaAdpt->ChSar);
|
|
DBG_DAC_INFO("dst addr:%x\n", pHALDACGdmaAdpt->ChDar);
|
|
pHALDACGdmaOp->HalGdmaChSeting(pHALDACGdmaAdpt);
|
|
|
|
pHALDACGdmaOp->HalGdmaChEn(pHALDACGdmaAdpt);
|
|
break;
|
|
}
|
|
case DAC_INPUT_DMA_LLP:
|
|
{
|
|
pHALDACGdmaAdpt->Rsvd4to7 = 1;
|
|
pHALDACGdmaAdpt->pLlix = (struct GDMA_CH_LLI *)pSalDACDmaUserDef->pLlix;
|
|
pHALDACGdmaAdpt->pBlockSizeList = (struct BLOCK_SIZE_LIST *)pSalDACDmaUserDef->pBlockSizeList;
|
|
pHALDACGdmaAdpt->ChDar = (u32)(DAC_REG_BASE+(pSalDACHND->DevNum*0x800));
|
|
pHALDACGdmaOp->HalGdmaChBlockSeting(pHALDACGdmaAdpt);
|
|
|
|
pHALDACGdmaOp->HalGdmaChEn(pHALDACGdmaAdpt);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
return _EXIT_FAILURE;
|
|
}
|
|
|
|
|
|
return _EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//Function Name:
|
|
// RtkI2CGetSalHnd
|
|
//
|
|
// Description:
|
|
// Allocation of lower layer memory spaces will be done by invoking RtkI2CGetMngtAdpt
|
|
// in this function and return a SAL_I2C_HND pointer to upper layer.
|
|
// According to the given I2C index, RtkI2CGetMngtAdpt will allocate all the memory
|
|
// space such as SAL_I2C_HND, HAL_I2C_INIT_DAT, SAL_I2C_USER_CB etc.
|
|
//
|
|
//
|
|
// Arguments:
|
|
// [in] u8 I2CIdx -
|
|
// I2C Index
|
|
//
|
|
// Return:
|
|
// PSAL_I2C_HND
|
|
// A pointer to SAL_I2C_HND which is allocated in the lower layer.
|
|
// Note:
|
|
// NA
|
|
//
|
|
// See Also:
|
|
// NA
|
|
//
|
|
// Author:
|
|
// By Jason Deng, 2014-04-03.
|
|
//
|
|
//----------------------------------------------------------------------------------------------------
|
|
PSAL_DAC_HND
|
|
RtkDACGetSalHnd(
|
|
IN u8 DACIdx
|
|
){
|
|
PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL;
|
|
PSAL_DAC_HND pSalDACHND = NULL;
|
|
|
|
/* Check the user define setting and the given index */
|
|
if (RtkDACIdxChk(DACIdx)) {
|
|
return (PSAL_DAC_HND)NULL;
|
|
}
|
|
|
|
/* Invoke RtkI2CGetMngtAdpt to get the I2C SAL management adapter pointer */
|
|
pSalDACMngtAdpt = RtkDACGetMngtAdpt(DACIdx);
|
|
|
|
/* Assign the private SAL handle to public SAL handle */
|
|
pSalDACHND = &(pSalDACMngtAdpt->pSalHndPriv->SalDACHndPriv);
|
|
|
|
/* Assign the internal HAL initial data pointer to the SAL handle */
|
|
pSalDACHND->pInitDat = pSalDACMngtAdpt->pHalInitDat;
|
|
|
|
/* Assign the internal user callback pointer to the SAL handle */
|
|
pSalDACHND->pUserCB = pSalDACMngtAdpt->pUserCB;
|
|
|
|
/* Assign the internal user DMA config to the SAL handle */
|
|
pSalDACHND->pDMAConf = pSalDACMngtAdpt->pDMAConf;
|
|
|
|
return &(pSalDACMngtAdpt->pSalHndPriv->SalDACHndPriv);
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//Function Name:
|
|
// RtkI2CGetSalHnd
|
|
//
|
|
// Description:
|
|
// Allocation of lower layer memory spaces will be done by invoking RtkI2CGetMngtAdpt
|
|
// in this function and return a SAL_I2C_HND pointer to upper layer.
|
|
// According to the given I2C index, RtkI2CGetMngtAdpt will allocate all the memory
|
|
// space such as SAL_I2C_HND, HAL_I2C_INIT_DAT, SAL_I2C_USER_CB etc.
|
|
//
|
|
//
|
|
// Arguments:
|
|
// [in] u8 I2CIdx -
|
|
// I2C Index
|
|
//
|
|
// Return:
|
|
// PSAL_I2C_HND
|
|
// A pointer to SAL_I2C_HND which is allocated in the lower layer.
|
|
// Note:
|
|
// NA
|
|
//
|
|
// See Also:
|
|
// NA
|
|
//
|
|
// Author:
|
|
// By Jason Deng, 2014-04-03.
|
|
//
|
|
//----------------------------------------------------------------------------------------------------
|
|
RTK_STATUS
|
|
RtkDACFreeSalHnd(
|
|
IN PSAL_DAC_HND pSalDACHND
|
|
){
|
|
PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL;
|
|
PSAL_DAC_HND_PRIV pSalDACHNDPriv = NULL;
|
|
|
|
/* To get the SAL_DAC_MNGT_ADPT pointer */
|
|
pSalDACHNDPriv = CONTAINER_OF(pSalDACHND, SAL_DAC_HND_PRIV, SalDACHndPriv);
|
|
pSalDACMngtAdpt = CONTAINER_OF(pSalDACHNDPriv->ppSalDACHnd, SAL_DAC_MNGT_ADPT, pSalHndPriv);
|
|
|
|
/* Invoke RtkDACFreeMngtAdpt to free all the lower layer memory space */
|
|
return (RtkDACFreeMngtAdpt(pSalDACMngtAdpt));
|
|
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//Function Name:
|
|
// RtkI2CLoadDefault
|
|
//
|
|
// Description:
|
|
// Accrording the given I2C index, the default I2C configuration is done.
|
|
//
|
|
//
|
|
// Arguments:
|
|
// [in] PSAL_I2C_HND pSalI2CHND -
|
|
// SAL I2C handle
|
|
//
|
|
// Return:
|
|
// The status of the loading I2C default configuration.
|
|
// _EXIT_SUCCESS if the RtkI2CLoadDefault succeeded.
|
|
// _EXIT_FAILURE if the RtkI2CLoadDefault failed.
|
|
//
|
|
// Note:
|
|
// NA
|
|
//
|
|
// See Also:
|
|
// NA
|
|
//
|
|
// Author:
|
|
// By Jason Deng, 2014-04-03.
|
|
//
|
|
//----------------------------------------------------------------------------------------------------
|
|
RTK_STATUS
|
|
RtkDACLoadDefault(
|
|
IN VOID *Data
|
|
){
|
|
PSAL_DAC_HND pSalDACHND = (PSAL_DAC_HND) Data;
|
|
|
|
/* Check the input DAC index first */
|
|
if (RtkDACIdxChk(pSalDACHND->DevNum))
|
|
return _EXIT_FAILURE;
|
|
|
|
/* Load SAL handle default value */
|
|
pSalDACHND->PinMux = 0;
|
|
pSalDACHND->OpType = DAC_POLL_TYPE;
|
|
pSalDACHND->DevSts = DAC_STS_UNINITIAL;
|
|
pSalDACHND->DACExd = 0;
|
|
pSalDACHND->ErrType = (u32)NULL;
|
|
|
|
/* Load HAL initial data structure default value */
|
|
pSalDACHND->pInitDat->DACIdx = pSalDACHND->DevNum;
|
|
pSalDACHND->pInitDat->DACEn = DAC_DISABLE;
|
|
pSalDACHND->pInitDat->DACDataRate = DAC_DATA_RATE_250K;
|
|
pSalDACHND->pInitDat->DACEndian = DAC_DATA_ENDIAN_LITTLE;
|
|
pSalDACHND->pInitDat->DACBurstSz = 7;
|
|
pSalDACHND->pInitDat->DACDbgSel = DAC_DBG_SEL_DISABLE;
|
|
pSalDACHND->pInitDat->DACDscDbgSel = DAC_DSC_DBG_SEL_DISABLE;
|
|
pSalDACHND->pInitDat->DACBPDsc = DAC_BYPASS_DSC_SEL_DISABLE;
|
|
pSalDACHND->pInitDat->DACDeltaSig = 0;
|
|
pSalDACHND->pInitDat->DACAnaCtrl0 = 0;
|
|
pSalDACHND->pInitDat->DACAnaCtrl1 = 0;
|
|
pSalDACHND->pInitDat->DACIntrMSK = DAC_FEATURE_DISABLED;
|
|
|
|
/* Load DAC DMA user configuration default value */
|
|
pSalDACHND->pDMAConf->MaxMultiBlk = 5000;
|
|
pSalDACHND->pDMAConf->TxDatSrcWdth = TrWidthFourBytes;
|
|
pSalDACHND->pDMAConf->TxDatSrcBstSz = MsizeFour;
|
|
pSalDACHND->pDMAConf->TxDatDstWdth = TrWidthFourBytes;
|
|
pSalDACHND->pDMAConf->TxDatDstBstSz = MsizeFour;
|
|
pSalDACHND->pDMAConf->TxChNo = 4;
|
|
|
|
return _EXIT_SUCCESS;
|
|
}
|