csl_mcbspgethwsetup.c

TI达芬奇dm644x各硬件模块测试代码

/** \file csl_mcbspGetHwSetup.c
 *
 *  \brief    File for functional layer of CSL API \a CSL_mcbspGetHwSetup()
 *
 *  Description
 *    - The \a CSL_mcbspGetHwSetup() function contains definition of the
 *      functional layer API
 *
 *  Path: \\(CSLPATH)\\ipmodules\\mcbsp\\src
 *
 */

#include <csl_mcbsp.h>

/**
 * Gets the status of some or all of the setup-parameters of MCBSP.
 * To get the status of complete MCBSP h/w setup, all the sub-structure
 * pointers inside the main HwSetup structure, should be non-NULL.
 *
 * <b> Usage Constraints: </b>
 * Both @a CSL_mcbspInit() and @a CSL_mcbspOpen() must be called successfully
 * in that order before @a CSL_mcbspGetHwSetup() can be called.
 *
 * @b Example:
 * @verbatim

   CSL_McbspHandle hMcbsp;
   CSL_Status status;

   CSL_McbspGlobalSetup gblSetup;
   CSL_McbspClkSetup clkSetup;
   CSL_McbspEmu emuMode;
   CSL_McbspHwSetup readSetup = {
       &gblSetup,
       NULL,    // RX Data-setup structure is not required
       NULL,    // TX Data-setup structure is not required
       &clkSetup,
       NULL,    // Multichannel-setup structure is not required
       emuMode
   };
   ...
   status = CSL_mcbspGetHwSetup(hMcbsp, &readSetup);

   @endverbatim
 *
 * @return Status of the operation
 *
 */
#pragma CODE_SECTION (CSL_mcbspGetHwSetup, ".text:csl_section:mcbsp");
CSL_Status  CSL_mcbspGetHwSetup(
    /** MCBSP handle returned by successful 'open' */
    CSL_McbspHandle                         hMcbsp,
    /** Pointer to @a CSL_McbspHwSetup structure to read the setup parameters*/
    CSL_McbspHwSetup                       *myHwSetup
)
{
    CSL_Status status = CSL_SOK;
    CSL_McbspRegsOvly mcbspRegs = hMcbsp->regs;
    if (myHwSetup->global != NULL) {
        CSL_McbspGlobalSetup *gbl = myHwSetup->global;

        gbl->dlbMode =
            (CSL_McbspDlbMode) CSL_FEXT(mcbspRegs->SPCR, MCBSP_SPCR_DLB);

        gbl->clkStopMode =
            (CSL_McbspClkStp) CSL_FEXT(mcbspRegs->SPCR, MCBSP_SPCR_CLKSTP);

        gbl->ioEnableMode =
            (CSL_McbspIOMode) (CSL_FEXT(mcbspRegs->PCR, MCBSP_PCR_RIOEN)
                           | (CSL_FEXT(mcbspRegs->PCR, MCBSP_PCR_XIOEN)<< 1));
    }
    
    if (myHwSetup->rxdataset != NULL) {
        CSL_McbspDataSetup *data = myHwSetup->rxdataset;

        data->phaseNum =
            (CSL_McbspPhase) CSL_FEXT(mcbspRegs->RCR, MCBSP_RCR_RPHASE);

        data->wordLength1 =
            (CSL_McbspWordLen) CSL_FEXT(mcbspRegs->RCR, MCBSP_RCR_RWDLEN1);

        data->wordLength2 =
            (CSL_McbspWordLen) CSL_FEXT(mcbspRegs->RCR, MCBSP_RCR_RWDLEN2);

        data->frmLength1 =   CSL_FEXT(mcbspRegs->RCR, MCBSP_RCR_RFRLEN1) + 1;
        data->frmLength2 =   CSL_FEXT(mcbspRegs->RCR, MCBSP_RCR_RFRLEN2) + 1;
        
        data->frmSyncIgn = 
            (CSL_McbspFrmSync) CSL_FEXT(mcbspRegs->RCR, MCBSP_RCR_RFIG);
            
        data->compand = 
            (CSL_McbspCompand) CSL_FEXT(mcbspRegs->RCR, MCBSP_RCR_RCOMPAND);
            
        data->dataDelay = 
            (CSL_McbspDataDelay) CSL_FEXT(mcbspRegs->RCR, MCBSP_RCR_RDATDLY);
            
        data->rjust_dxenable =
           (CSL_McbspRjustDxena) CSL_FEXT(mcbspRegs->SPCR, MCBSP_SPCR_RJUST);
           
        data->IntEvent = 
            (CSL_McbspIntMode) CSL_FEXT(mcbspRegs->SPCR, MCBSP_SPCR_RINTM);
            
        data->wordReverse = 
            (CSL_McbspBitReversal)CSL_FEXT (mcbspRegs->RCR, MCBSP_RCR_RWDREVRS);
    }
    
    if (myHwSetup->txdataset != NULL) {
        CSL_McbspDataSetup *data = myHwSetup->txdataset;

        data->phaseNum = 
            (CSL_McbspPhase) CSL_FEXT(mcbspRegs->XCR, MCBSP_XCR_XPHASE);
            
        data->wordLength1 = 
            (CSL_McbspWordLen) CSL_FEXT(mcbspRegs->XCR, MCBSP_XCR_XWDLEN1);
            
        data->wordLength2 = 
            (CSL_McbspWordLen) CSL_FEXT(mcbspRegs->XCR, MCBSP_XCR_XWDLEN2);
            
        data->frmLength1 =   CSL_FEXT(mcbspRegs->XCR, MCBSP_XCR_XFRLEN1) + 1;
        data->frmLength2 =   CSL_FEXT(mcbspRegs->XCR, MCBSP_XCR_XFRLEN2) + 1;
        
        data->frmSyncIgn = 
            (CSL_McbspFrmSync) CSL_FEXT(mcbspRegs->XCR, MCBSP_XCR_XFIG);
            
        data->compand = 
            (CSL_McbspCompand) CSL_FEXT(mcbspRegs->XCR, MCBSP_XCR_XCOMPAND);
            
        data->dataDelay = 
            (CSL_McbspDataDelay) CSL_FEXT(mcbspRegs->XCR, MCBSP_XCR_XDATDLY);
            
        data->rjust_dxenable =
           (CSL_McbspRjustDxena) CSL_FEXT(mcbspRegs->SPCR, MCBSP_SPCR_DXENA);
           
        data->IntEvent = 
            (CSL_McbspIntMode) CSL_FEXT(mcbspRegs->SPCR, MCBSP_SPCR_XINTM);
            
        data->wordReverse = 
            (CSL_McbspBitReversal)CSL_FEXT (mcbspRegs->XCR, MCBSP_XCR_XWDREVRS);
    }
    if (myHwSetup->clkset != NULL) {
        CSL_McbspClkSetup *clk = myHwSetup->clkset; 
        
        clk->frmSyncRxMode = 
            (CSL_McbspFsClkMode) CSL_FEXT(mcbspRegs->PCR, MCBSP_PCR_FSRM);
            
        clk->frmSyncTxMode = 
            (CSL_McbspFsClkMode) CSL_FEXT(mcbspRegs->PCR, MCBSP_PCR_FSXM);
            
        clk->frmSyncRxPolarity = 
            (CSL_McbspFsPol) CSL_FEXT(mcbspRegs->PCR, MCBSP_PCR_FSRP);
            
        clk->frmSyncTxPolarity = 
            (CSL_McbspFsPol) CSL_FEXT(mcbspRegs->PCR, MCBSP_PCR_FSXP);
            
        clk->clkRxMode = 
            (CSL_McbspTxRxClkMode) CSL_FEXT(mcbspRegs->PCR, MCBSP_PCR_CLKRM);
            
        clk->clkTxMode = 
            (CSL_McbspTxRxClkMode) CSL_FEXT(mcbspRegs->PCR, MCBSP_PCR_CLKXM);
            
        clk->clkRxPolarity = 
            (CSL_McbspClkPol) CSL_FEXT(mcbspRegs->PCR, MCBSP_PCR_CLKRP);
            
        clk->clkTxPolarity = 
            (CSL_McbspClkPol) CSL_FEXT(mcbspRegs->PCR, MCBSP_PCR_CLKXP);
            
        clk->srgFrmPulseWidth = CSL_FEXT(mcbspRegs->SRGR, MCBSP_SRGR_FWID);
        clk->srgFrmPeriod = CSL_FEXT(mcbspRegs->SRGR, MCBSP_SRGR_FPER);
        clk->srgClkDivide = CSL_FEXT(mcbspRegs->SRGR, MCBSP_SRGR_CLKGDV);
        
        clk->srgClkSync = 
            (CSL_McbspClkgSyncMode) CSL_FEXT(mcbspRegs->SRGR, MCBSP_SRGR_GSYNC);
            
        clk->srgInputClkMode =
           (CSL_McbspSrgClk) (  CSL_FEXT(mcbspRegs->SRGR, MCBSP_SRGR_CLKSM)
                    | (CSL_FEXT(mcbspRegs->PCR, MCBSP_PCR_SCLKME) >> 0x1 ) );
                    
        clk->srgClkPolarity = 
            (CSL_McbspClkPol) CSL_FEXT(mcbspRegs->SRGR, MCBSP_SRGR_CLKSP);
            
        clk->srgTxFrmSyncMode =
           (CSL_McbspTxFsMode) CSL_FEXT(mcbspRegs->SRGR, MCBSP_SRGR_FSGM);
    }
    
    if (myHwSetup->mulCh != NULL) {
        CSL_McbspMulChSetup *mulch = myHwSetup->mulCh;

        mulch->rxMulChSel = CSL_FEXT(mcbspRegs->MCR, MCBSP_MCR_RMCM);
        mulch->txMulChSel = CSL_FEXT(mcbspRegs->MCR, MCBSP_MCR_XMCM);
        mulch->rxPartition = 
            (CSL_McbspPartMode) CSL_FEXT(mcbspRegs->MCR, MCBSP_MCR_RMCME);
            
        mulch->rxPartABlk = 
            (CSL_McbspPABlk) CSL_FEXT(mcbspRegs->MCR, MCBSP_MCR_RPABLK);
            
        mulch->rxPartBBlk = 
            (CSL_McbspPBBlk) CSL_FEXT(mcbspRegs->MCR, MCBSP_MCR_RPBBLK);
            
        mulch->txPartition = 
            (CSL_McbspPartMode) CSL_FEXT(mcbspRegs->MCR, MCBSP_MCR_XMCME);
            
        mulch->txPartABlk = 
            (CSL_McbspPABlk) CSL_FEXT(mcbspRegs->MCR, MCBSP_MCR_XPABLK);
            
        mulch->txPartBBlk = 
            (CSL_McbspPBBlk) CSL_FEXT(mcbspRegs->MCR, MCBSP_MCR_XPBBLK);
            
        mulch->rx512channel = CSL_FEXT (mcbspRegs->MCR, MCBSP_MCR_REMODE);
        mulch->tx512channel = CSL_FEXT (mcbspRegs->MCR, MCBSP_MCR_XEMODE);
    }
    
    {
        Uint16 tempValue;

        tempValue =   CSL_FEXT( mcbspRegs->SPCR, MCBSP_SPCR_SOFT)
                   | (CSL_FEXT( mcbspRegs->SPCR, MCBSP_SPCR_FREE) << 1);
        if (tempValue == 3) tempValue = 2;
        myHwSetup->emumode = (CSL_McbspEmu) tempValue;
    }

    myHwSetup->dxState = 
        (CSL_McbspDxState)CSL_FEXT( mcbspRegs->MCR, MCBSP_MCR_DX);
        
    myHwSetup->rxsynccount = mcbspRegs->RSYNCCNT;
    myHwSetup->txsynccount = mcbspRegs->XSYNCCNT;
    myHwSetup->extendSetup = NULL;
    return(status);
}