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);
}