mcbsp_sinchannel_example.c

Dm6455 driver,magbe useful to you!

    readHwSetup.txdataset = &txDataSetup;
    readHwSetup.clkset = &clkSetup;

    /* Data Arrays */   
    for (loopIndex = 0; loopIndex < NumOfWords; loopIndex++) {
      xmt[loopIndex] = loopIndex;
      rcv[loopIndex] = 0;
    }

    printf("\n***singleChannelTransmission***\n");

    /* Initialize the MCBSP CSL module */
    status = CSL_mcbspInit(&pContext);
    if (status != CSL_SOK) {
        printf("Mcbsp initialization failed\n");
        return;
    }

    /* Open the CSL module */
    hMcbsp = CSL_mcbspOpen (&mcbspObj, CSL_MCBSP_0, NULL, &status);
    if ((hMcbsp == NULL) || (status != CSL_SOK)) {
        printf ("MCBSP: Opening instance... Failed.\n");
        printf ("\tReason: Error opening the instance. \
                [status = 0x%x, hMcbsp = 0x%x]\n", status, hMcbsp);
        exit(1);
    }
    
    /* Disable MCBSP transmit and receive */
    ctrlMask = CSL_MCBSP_CTRL_RX_DISABLE 
               | CSL_MCBSP_CTRL_TX_DISABLE
               | CSL_MCBSP_CTRL_FSYNC_DISABLE 
               | CSL_MCBSP_CTRL_SRG_DISABLE;
    CSL_mcbspHwControl (hMcbsp, CSL_MCBSP_CMD_RESET_CONTROL, &ctrlMask);
    
    /* Setup hardware parameters */
    status= CSL_mcbspHwSetup (hMcbsp , &myHwSetup);
    if (status != CSL_SOK){
        printf ("MCBSP: Hardware setup... Failed.\n");
        exit(1);
    }
    
    /* Get Hw setup Parameters */
    status = CSL_mcbspGetHwSetup (hMcbsp , &readHwSetup); 
    if (status != CSL_SOK){
        printf ("MCBSP: Get Hardware setup... Failed.\n");
        exit(1);
    }
    
    /* Compare the hardware setup parameter values passed in the
     * "hwSetup" structure by comparing them with the actual values read from
     * the Mcbsp registers 
     */
    status = hwSetupVerify (&myHwSetup, &readHwSetup);
    if (status != CSL_SOK){
        printf ("MCBSP: Hardware setup and Read Hardware setup parameter "); 
        printf ("comparision ... Failed.\n");
        exit(1);
    }

    /* Start sample rate generator and wait for 2 clock cycles */
    ctrlMask = CSL_MCBSP_CTRL_SRG_ENABLE | CSL_MCBSP_CTRL_FSYNC_ENABLE;
    CSL_mcbspHwControl(hMcbsp, CSL_MCBSP_CMD_RESET_CONTROL, &ctrlMask); 
    
    WAIT_FOR_2_CLK;
    
    /* Enable MCBSP transmit and receive and wait for 2 clock cycles */
    ctrlMask = CSL_MCBSP_CTRL_TX_ENABLE | CSL_MCBSP_CTRL_RX_ENABLE;
    CSL_mcbspHwControl(hMcbsp, CSL_MCBSP_CMD_RESET_CONTROL, &ctrlMask);
     
    WAIT_FOR_2_CLK;      

    for(loopIndex = 0; loopIndex < NumOfWords; loopIndex++) {
        timeout = 0;

        /* Wait for XRDY signal before writing data to DXR */
        response = 0;
        while ((timeout++ < maxTimeout) && !(response & CSL_MCBSP_XRDY)) {
            CSL_mcbspGetHwStatus(hMcbsp, CSL_MCBSP_QUERY_DEV_STATUS, &response);
        }
        
        if(timeout >= maxTimeout) {
            printf("MCBSP: Example Failed\n");
            printf("\tReason: Failed to make the transmitter ready\n");
            exit(1);
        }

        /* Write 16 bit data value to DXR */
        CSL_mcbspWrite (hMcbsp, CSL_MCBSP_WORDLEN_16, &xmt[loopIndex]);

        timeout = 0;
        
        /* Read 16 bit value from DRR and check the data */
        response = 0;
        while ((timeout++ < maxTimeout) && !(response & CSL_MCBSP_RRDY)) {
            CSL_mcbspGetHwStatus(hMcbsp, CSL_MCBSP_QUERY_DEV_STATUS, &response);
        }
        
        /* Read 16 bit value from DRR */
        CSL_mcbspRead (hMcbsp, CSL_MCBSP_WORDLEN_16, &rcv[loopIndex]);
        if(xmt[loopIndex] != rcv[loopIndex])
            errCount++;
    }

    /* Check the data to make sure transfer was successful and print data */
    for(loopIndex = 0; loopIndex <= NumOfWords - 1; loopIndex++) {
        if (xmt[loopIndex] != rcv[loopIndex]) {
            printf("xmt[%d] != rcv[%d]\n", loopIndex, loopIndex);        
        }
        else {
            printf("xmt[%d] == rcv[%d]\n", loopIndex, loopIndex);
        }
    }

    /* Check for error count to display example result */
    if (errCount > 0) {
        printf("MCBSP: Single Channel Transmission Example... Failed.\n");
    
    }
    else {
        printf("MCBSP: Single Channel Transmission Example... Success.\n");            
    }   
}

/*
 * ============================================================================
 *   @func   hwSetupVerify
 *
 *   @desc
 *     This function compare the hardware setup parameter values passed in the
 *     "hwSetup" structure by comparing them with the actual values read from
 *     the Mcbsp registers.
 *
 *   @arg    hwSetup
 *       Pointer to the buffer containing the hardware setup parameters that
 *       are needed to be compare
 *   @arg    hwSetupRead
 *       Pointer to the buffer containing the get hardware setup parameters that
 *       are needed to be compared with setup parameters
 *
 * ============================================================================
*/
CSL_Status hwSetupVerify (
      CSL_McbspHwSetup    *hwSetup,
      CSL_McbspHwSetup    *hwSetupRead
)
{ 
    CSL_Status    status = CSL_SOK;
    
    /* Check the mcbsp global setup parameters */
    if (hwSetupRead->global != NULL) {
        if(!((hwSetup->global->dlbMode == hwSetupRead->global->dlbMode) 
            &&(hwSetup->global->clkStopMode == \
                                             hwSetupRead->global->clkStopMode) 
            &&(hwSetup->global->ioEnableMode == \
                                        hwSetupRead->global->ioEnableMode))) {
            status = CSL_ESYS_FAIL;
        } 
    }  
    
    /* Check the mcbsp receive data setup parameters */
    if (hwSetupRead->rxdataset != NULL) {
        if (!((hwSetup->rxdataset->numPhases == \
                                           hwSetupRead->rxdataset->numPhases)
            &&(hwSetup->rxdataset->wordLength1 == \
                                        hwSetupRead->rxdataset->wordLength1) 
            &&(hwSetup->rxdataset->wordLength2 == \
                                        hwSetupRead->rxdataset->wordLength2)
            &&(hwSetup->rxdataset->frmLength1 == \
                                        hwSetupRead->rxdataset->frmLength1)
            &&(hwSetup->rxdataset->frmSyncIgn  == \
                                        hwSetupRead->rxdataset->frmSyncIgn)
            &&(hwSetup->rxdataset->compand == \
                                        hwSetupRead->rxdataset->compand)
            && (hwSetup->rxdataset->dataDelay == \
                                        hwSetupRead->rxdataset->dataDelay)
            &&(hwSetup->rxdataset->rjust_dxenable == \
                                        hwSetupRead->rxdataset->rjust_dxenable)
            &&(hwSetup->rxdataset->intEvent == \
                                        hwSetupRead->rxdataset->intEvent)
            &&(hwSetup->rxdataset->wordReverse == \
                                       hwSetupRead->rxdataset->wordReverse))) {
               
            status = CSL_ESYS_FAIL;
        }
    }
    
    /* Check the mcbsp transmit data setup parameters */
    if (hwSetupRead->txdataset != NULL) {
        if (!((hwSetup->txdataset->numPhases == \
                                        hwSetupRead->txdataset->numPhases) 
            &&(hwSetup->txdataset->wordLength1 == \
                                        hwSetupRead->txdataset->wordLength1)
            &&(hwSetup->txdataset->wordLength2 == \
                                        hwSetupRead->txdataset->wordLength2)
            &&(hwSetup->txdataset->frmLength1 == \
                                        hwSetupRead->txdataset->frmLength1)
            &&(hwSetup->txdataset->frmSyncIgn == \
                                        hwSetupRead->txdataset->frmSyncIgn)
            &&(hwSetup->txdataset->compand == \
                                        hwSetupRead->txdataset->compand)
            &&(hwSetup->txdataset->dataDelay == \
                                        hwSetupRead->txdataset->dataDelay)
            &&(hwSetup->txdataset->rjust_dxenable == \
                                        hwSetupRead->txdataset->rjust_dxenable)
            &&(hwSetup->txdataset->intEvent == \
                                        hwSetupRead->txdataset->intEvent)
            &&(hwSetup->txdataset->wordReverse == \
                                       hwSetupRead->txdataset->wordReverse))) {
           
            status = CSL_ESYS_FAIL;
        }
    }

    /* Check the mcbsp clock setup parameters */
    if (hwSetupRead->clkset != NULL) {
        if (!((hwSetup->clkset->frmSyncRxMode == \
                                        hwSetupRead->clkset->frmSyncRxMode)
            &&(hwSetup->clkset->frmSyncTxMode == \
                                        hwSetupRead->clkset->frmSyncTxMode)
            &&(hwSetup->clkset->frmSyncRxPolarity == \
                                        hwSetupRead->clkset->frmSyncRxPolarity)
            &&(hwSetup->clkset->frmSyncTxPolarity == \
                                        hwSetupRead->clkset->frmSyncTxPolarity)
            &&(hwSetup->clkset->clkRxMode == \
                                        hwSetupRead->clkset->clkRxMode)
            &&(hwSetup->clkset->clkTxMode == \
                                        hwSetupRead->clkset->clkTxMode)
            &&(hwSetup->clkset->clkRxPolarity == \
                                    hwSetupRead->clkset->clkRxPolarity)
            &&(hwSetup->clkset->clkTxPolarity == \
                                    hwSetupRead->clkset->clkTxPolarity)
            &&(hwSetup->clkset->srgFrmPulseWidth  == \
                                    hwSetupRead->clkset->srgFrmPulseWidth)
            &&(hwSetup->clkset->srgFrmPeriod == \
                                    hwSetupRead->clkset->srgFrmPeriod)
            &&(hwSetup->clkset->srgClkDivide == \
                                    hwSetupRead->clkset->srgClkDivide)
            &&(hwSetup->clkset->srgClkSync == \
                                    hwSetupRead->clkset->srgClkSync)
            &&(hwSetup->clkset->srgInputClkMode == \
                                    hwSetupRead->clkset->srgInputClkMode)
            &&(hwSetup->clkset->srgClkPolarity == \
                                    hwSetupRead->clkset->srgClkPolarity)
            &&(hwSetup->clkset->srgTxFrmSyncMode == \
                                    hwSetupRead->clkset->srgTxFrmSyncMode))) {
            
            status = CSL_ESYS_FAIL;
        }
    }
    
    /* Check the mcbsp emulation mode setup parameters */
    if(!((hwSetup->emumode == hwSetupRead->emumode ) &&
        (hwSetup->extendSetup == hwSetupRead->extendSetup))) {
        
        status = CSL_ESYS_FAIL;
    }

    return status;
}