wmxscaledma.c

WM9713 audio codec driver for WinCE 5.0

    {
        WM_TRACE( hDevice, ( "***** Error in DMA registers *****" ));
        return;
    }

    /*
     * Do some lookups.
     */
    v_pDmaReg = pDeviceContext->v_pDmaReg;
    dmaChannel = pChannelDef->DMAChannel;
    device = pChannelDef->pDetails->DMADevice;
    
    /* DCSR - DMA state */
    WM_TRACE( hDevice, ( "v_pDmaReg->DCSR[%02d]      %X",
                         dmaChannel,
                         v_pDmaReg->DCSR[dmaChannel]
                       )
            );
            
    /* DINT - DMA interrupt */
    WM_TRACE( hDevice, ( "v_pDmaReg->DINT          %X", v_pDmaReg->DINT ));

    /* DRCMR - controller mask register */
    WM_TRACE( hDevice, ( "v_pDmaReg->DRCMR[%d]     %X",
                         device,
                         v_pDmaReg->DRCMR1[device]
                       )
            );

    /* Loaded descriptor */
    WM_TRACE( hDevice, ( "v_pDmaReg->DDG[%02d].DDADR %X",
                         dmaChannel,
                         v_pDmaReg->DDG[dmaChannel].DDADR
                       )
            );
    WM_TRACE( hDevice, ( "v_pDmaReg->DDG[%d].DSADR %X",
                         dmaChannel,
                         v_pDmaReg->DDG[dmaChannel].DSADR
                       )
            );
    WM_TRACE( hDevice, ( "v_pDmaReg->DDG[%d].DTADR %X",
                         dmaChannel,
                         v_pDmaReg->DDG[dmaChannel].DTADR
                       )
            );
    WM_TRACE( hDevice, ( "v_pDmaReg->DDG[%d].DCMD  %X",
                         dmaChannel,
                         v_pDmaReg->DDG[dmaChannel].DCMD
                       )
            );

    /* Current descriptors */
    WM_TRACE( hDevice, ( "descriptor1.DDADR        %X",
                         pChannelDef->desc1->DDADR
                       )
            );
    WM_TRACE( hDevice, ( "descriptor1.DSADR        %X",
                         pChannelDef->desc1->DSADR
                       )
            );
    WM_TRACE( hDevice, ( "descriptor1.DTADR        %X",
                         pChannelDef->desc1->DTADR
                       )
            );
    WM_TRACE( hDevice, ( "descriptor1.DCMD         %X",
                         pChannelDef->desc1->DCMD
                       )
            );
    WM_TRACE( hDevice, ( "descriptor2.DDADR        %X",
                         pChannelDef->desc2->DDADR
                       )
            );
    WM_TRACE( hDevice, ( "descriptor2.DSADR        %X",
                         pChannelDef->desc2->DSADR
                       )
            );
    WM_TRACE( hDevice, ( "descriptor2.DTADR        %X",
                         pChannelDef->desc2->DTADR
                       )
            );
    WM_TRACE( hDevice, ( "descriptor2.DCMD         %X",
                         pChannelDef->desc2->DCMD
                       )
            );

    return;    
}

/*-----------------------------------------------------------------------------
 * Function: private_DumpDmacRegs
 * 
 * Purpose: Output the value of  DMAC registers (for debugging purposes only).
 *  
 * Parameters:
 *      hDevice     handle to the device (from WMOpenDevice)
 *
 * Returns:      void.
 *
 ----------------------------------------------------------------------------*/
static void private_DumpDmacRegs( WM_DEVICE_HANDLE hDevice )
{
	WM_XSCALE_DEVICE_CONTEXT *pDeviceContext =
								(WM_XSCALE_DEVICE_CONTEXT*) hDevice;
	
	int						i;

	if (NULL == pDeviceContext || NULL == pDeviceContext->v_pDmaReg )
	{
		WM_TRACE( hDevice, ( "***** Error in DMA registers *****" ));
		return;
	}

	WM_TRACE( hDevice, ( "*******************************************************" ));
	WM_TRACE( hDevice, ( "***** private_DumpDmacRegs printing DMA registers *****" ));

	for (i=0; i< XLLP_DMAC_CHANNEL_NUM; i++)
	{
		private_OutputGivenDmacRegs( hDevice, pDeviceContext->v_pDmaReg );
	}


	WM_TRACE( hDevice, ( "***** private_DumpDmacRegs finished DMA registers *****" ));
	WM_TRACE( hDevice, ( "*******************************************************" ));

	return;
}

/*-----------------------------------------------------------------------------
 * Function: private_OutputGivenDmacRegs
 * 
 * Purpose: Output the value of recorded DMAC registers 
 *			(for debugging purposes only).
 *  
 * Parameters:
 *      hDevice     handle to the device (from WMOpenDevice)
 *      pDmacRegs     handle to the device (from WMOpenDevice)
 *
 * Returns:      void.
 *
 ----------------------------------------------------------------------------*/
static void private_OutputGivenDmacRegs( WM_DEVICE_HANDLE     hDevice, 
										 volatile XLLP_DMAC_T *pDmacRegs )
{
	WM_XSCALE_DEVICE_CONTEXT *pDeviceContext =
								(WM_XSCALE_DEVICE_CONTEXT*) hDevice;
					
	int						    i;	for (i=0; i< XLLP_DMAC_CHANNEL_NUM; i++)
	{
		WM_TRACE( hDevice, ( "DMAC Registers->DCSR[%d]	   0x%08X", i, pDmacRegs->DCSR[i] ));
	}

#if WM_BOARD_MAINSTONEII 
	//skip rsvd section RESERVED0[0x8];

	WM_TRACE( hDevice, ( "DMAC Registers->DALGN[%d]	   0x%08X", i, pDmacRegs->DALGN ));

	//skip rsvd section RESERVED1[0xF];

	WM_TRACE( hDevice, ( "DMAC Registers->DRQSR0[%d]	   0x%08X", i, pDmacRegs->DRQSR0 ));
	WM_TRACE( hDevice, ( "DMAC Registers->DRQSR1[%d]	   0x%08X", i, pDmacRegs->DRQSR1 ));

	//skip rsvd section RESERVED2[0x2];

#else /* WM_BOARD_MAINSTONEII  */
	//skip rsvd section rsvd0[44];
#endif /* WM_BOARD_MAINSTONEII  */

	WM_TRACE( hDevice, ( "DMAC Registers->DINT	   0x%08X", pDmacRegs->DINT ));

	//skip rsvd seciton rsvd1[3];

	for (i=0; i< XLLP_DMAC_DRCMR1_NUM; i++)
	{
		WM_TRACE( hDevice, ( "DMAC Registers->DRCMR[%d]	   0x%08X", i, pDmacRegs->DRCMR1[i] ));
	}

#if !WM_BOARD_MAINSTONEII
	//skip rsvd section rsvd2[24];
#endif /* !WM_BOARD_MAINSTONEII  */

	for (i=0; i<XLLP_DMAC_CHANNEL_NUM; i++)
	{
		WM_TRACE( hDevice, ( "DMAC Registers->DDG[%d].DDADR  0x%08X", i, pDmacRegs->DDG[i].DDADR ));
		WM_TRACE( hDevice, ( "DMAC Registers->DDG[%d].DSADR  0x%08X", i, pDmacRegs->DDG[i].DSADR ));
		WM_TRACE( hDevice, ( "DMAC Registers->DDG[%d].DTADR  0x%08X", i, pDmacRegs->DDG[i].DTADR ));
		WM_TRACE( hDevice, ( "DMAC Registers->DDG[%d].DCMD   0x%08X", i, pDmacRegs->DDG[i].DCMD ));
	}

#if WM_BOARD_MAINSTONEII 

	//skip rsvd section RESERVED4[0x340];

	for (i=0; i< XLLP_DMAC_DRCMR2_NUM; i++)
	{
		WM_TRACE( hDevice, ( "DMAC Registers->DRCMR2[%d]	   0x%08X", i, pDmacRegs->DRCMR2[i] ));
	}

	//skip rsvd section RESERVED5[0x3FBBD];

#endif /* WM_BOARD_MAINSTONEII  */

	return;
}

#if WMDMA_DMA_STORE_DEBUG
/*-----------------------------------------------------------------------------
 * Function: private_CaptureDmacRegs
 * 
 * Purpose: Record the value of  DMAC registers (for debugging purposes only).
 *			(Recording is less intrusive than printing the registers immediately).
 *  
 * Parameters:
 *      hDevice     handle to the device (from WMOpenDevice)
 *
 * Returns:      void.
 *
 ----------------------------------------------------------------------------*/
static void private_CaptureDmacRegs( WM_DEVICE_HANDLE hDevice )
{
	volatile XLLP_DMAC_T		*v_pDmaRegs		= NULL;
	WM_XSCALE_DEVICE_CONTEXT	*pDeviceContext =
									(WM_XSCALE_DEVICE_CONTEXT*) hDevice;

	/* Check we have enough space */
	WM_ASSERT( hDevice, DmaDebugRun < MAX_DMA_DEBUG ); 

	if ( NULL == pDeviceContext || NULL == pDeviceContext->v_pDmaReg )
	{
		WM_TRACE( hDevice, ( "***** Error in DMA registers *****" ));
		return;
	}

	v_pDmaRegs = pDeviceContext->v_pDmaReg;

	/* Copy the registers */
	DmacRegsStore[DmaDebugRun] = *v_pDmaRegs;

	/* increment for next use */
	++DmaDebugRun;

	return;
}

/*-----------------------------------------------------------------------------
 * Function: private_DumpCapturedDmacRegs
 * 
 * Purpose: Output the value of recorded DMAC registers 
 *			(for debugging purposes only).
 *  
 * Parameters:
 *      hDevice		handle to the device (from WMOpenDevice)
 *      run			incex to stored DMAC values
 *
 * Returns:      void.
 *
 ----------------------------------------------------------------------------*/
static void private_DumpCapturedDmacRegs( WM_DEVICE_HANDLE hDevice, int run )
{
	WM_XSCALE_DEVICE_CONTEXT  *pDeviceContext =
								(WM_XSCALE_DEVICE_CONTEXT*) hDevice;

	if (NULL == pDeviceContext || NULL == pDeviceContext->v_pDmaReg )
	{
		WM_TRACE( hDevice, ( "***** Error in DMA registers *****" ));
		return;
	}

	WM_TRACE( hDevice, ( "****************************************************************" ));
	WM_TRACE( hDevice, ( "*** private_DumpCapturedDmacRegs printing DMA registers [%2d] ***", run ));

	private_OutputGivenDmacRegs( hDevice, &DmacRegsStore[run] );

	WM_TRACE( hDevice, ( "*** private_DumpCapturedpDmacRegs finished DMA registers [%2d] ***", run ));
	WM_TRACE( hDevice, ( "****************************************************************" ));

	return;
}

/*-----------------------------------------------------------------------------
 * Function: private_DumpAllCapturedDmacRegs
 * 
 * Purpose: Output the value of  DMAC registers (for debugging purposes only).
 * 			Stored register values will be overwritten after this call.
 *  
 * Parameters:
 *      hDevice     handle to the device (from WMOpenDevice)
 *
 * Returns:      void.
 *
 ----------------------------------------------------------------------------*/
static void private_DumpAllCapturedDmacRegs( WM_DEVICE_HANDLE hDevice )
{
	int i;
	
    /*
     * Dump each set of stored registers.
     */	
	for ( i = 0; i < MAX_DMA_DEBUG && i < DmaDebugRun; i++ )
	{
		private_DumpCapturedDmacRegs( hDevice, i );
	}

    /*
     * Reset debugging array
     */
	DmaDebugRun = 0;

	return;
}
#endif /* WMDMA_DMA_STORE_DEBUG */

#endif /* DEBUG */

#if WM_TESTING
/*-----------------------------------------------------------------------------
 * Function:    WMTestDMAInternals
 *
 * This function tests the internal code in WMDMA.c.
 *
 * Parameters:
 *      hDevice     Device handle to use
 *
 * Returns:     WM_BOOL
 *      TRUE if it worked.
 *---------------------------------------------------------------------------*/
WMTEST_START( WMTestDMAInternals( WM_DEVICE_HANDLE hDevice ) )
{
    WM_XSCALE_DEVICE_CONTEXT *pDeviceContext =
								(WM_XSCALE_DEVICE_CONTEXT*) hDevice;

    if ( pDeviceContext->pDMAContext )
    {
        WMTEST_RUN( private_TestIsBufferAvailable( hDevice ) );
    }
    else
    {
        WMTEST_TRACE(( "WMTestDMAInternals: no DMA context - skipping test\n" ));
    }
}
WMTEST_END

/*-----------------------------------------------------------------------------
 * Function:    private_TestIsBufferAvailable
 *
 * This function tests the IS_BUFFER_AVAILABLE macro.
 *
 * Parameters:
 *      hDevice	 Device context to use to look up the DMA context.
 *
 * Returns:     WM_BOOL
 *      TRUE if it worked.
 *---------------------------------------------------------------------------*/
WMTEST_STATIC_START( private_TestIsBufferAvailable( WM_DEVICE_HANDLE hDevice ) )
{
    ChannelDef channelDef;
	WMAUDIO_CHANNEL APIChannelInput, APIChannelOutput;
    WM_DEVICE_CONTEXT *pDeviceContext = WMHANDLE_TO_DEVICE( hDevice );
    WM_DEVICE_ID deviceID = pDeviceContext->deviceID;

#if WM_AC97
    if ( WM_IS_AC97_DEVICE_ID( deviceID ) )
    {
		APIChannelInput  = WMAUDIO_AC97_STEREO_IN;
		APIChannelOutput = WMAUDIO_AC97_STEREO_OUT;
	}
#endif /* WM_AC97 */

#if WM_I2S
    if ( WM_IS_I2S_DEVICE_ID( deviceID ) )
    {
		APIChannelInput  = WMAUDIO_I2S_STEREO_IN;
		APIChannelOutput = WMAUDIO_I2S_STEREO_OUT;
	}
#endif /* WM_I2S */


    /************
     * INPUT
     */
    memset( &channelDef, 0, sizeof( channelDef ) );
    channelDef.pDetails = WMDMAGetChannelDetails( hDevice,
                                                  APIChannelInput
                                                );

    /*
     * Both buffers empty - should fail.
     */
    WMTEST_FALSE( IS_BUFFER_AVAILABLE( &channelDef, BUF1 ) );
    WMTEST_FALSE( IS_BUFFER_AVAILABLE( &channelDef, BUF2 ) );
    
    /*
     * Set BUF1 full - should work, BUF2 should fail.
     */
    channelDef.flags |= WMCHAN_BUF1_FULL;
    WMTEST_TRUE( IS_BUFFER_AVAILABLE( &channelDef, BUF1 ) );
    WMTEST_FALSE( IS_BUFFER_AVAILABLE( &channelDef, BUF2 ) );
    
    /*
     * Set BUF2 full - both should work.
     */
    channelDef.flags |= WMCHAN_BUF2_FULL;
    WMTEST_TRUE( IS_BUFFER_AVAILABLE( &channelDef, BUF1 ) );
    WMTEST_TRUE( IS_BUFFER_AVAILABLE( &channelDef, BUF2 ) );
    
    /*
     * Set BUF1 empty - BUF2 (only) should work.
     */
    channelDef.flags &= ~WMCHAN_BUF1_FULL;
    WMTEST_FALSE( IS_BUFFER_AVAILABLE( &channelDef, BUF1 ) );
    WMTEST_TRUE( IS_BUFFER_AVAILABLE( &channelDef, BUF2 ) );

    /*
     * Set BUF2 empty again - both should fail.
     */
    channelDef.flags &= ~WMCHAN_BUF2_FULL;
    WMTEST_FALSE( IS_BUFFER_AVAILABLE( &channelDef, BUF1 ) );
    WMTEST_FALSE( IS_BUFFER_AVAILABLE( &channelDef, BUF2 ) );

    /************
     * OUTPUT
     */
    memset( &channelDef, 0, sizeof( channelDef ) );
    channelDef.pDetails = WMDMAGetChannelDetails( hDevice,
                                                  APIChannelOutput
                                                );

    /*
     * Both buffers empty - should pass.
     */
    WMTEST_TRUE( IS_BUFFER_AVAILABLE( &channelDef, BUF1 ) );
    WMTEST_TRUE( IS_BUFFER_AVAILABLE( &channelDef, BUF2 ) );
    
    /*
     * Set BUF1 full - should fail, BUF2 should pass.
     */
    channelDef.flags |= WMCHAN_BUF1_FULL;
    WMTEST_FALSE( IS_BUFFER_AVAILABLE( &channelDef, BUF1 ) );
    WMTEST_TRUE( IS_BUFFER_AVAILABLE( &channelDef, BUF2 ) );
    
    /*
     * Set BUF2 full - both should fail.
     */
    channelDef.flags |= WMCHAN_BUF2_FULL;
    WMTEST_FALSE( IS_BUFFER_AVAILABLE( &channelDef, BUF1 ) );
    WMTEST_FALSE( IS_BUFFER_AVAILABLE( &channelDef, BUF2 ) );
    
    /*
     * Set BUF1 empty - BUF1 (only) should work.
     */
    channelDef.flags &= ~WMCHAN_BUF1_FULL;
    WMTEST_TRUE( IS_BUFFER_AVAILABLE( &channelDef, BUF1 ) );
    WMTEST_FALSE( IS_BUFFER_AVAILABLE( &channelDef, BUF2 ) );

    /*
     * Set BUF2 empty again - both should pass.
     */
    channelDef.flags &= ~WMCHAN_BUF2_FULL;
    WMTEST_TRUE( IS_BUFFER_AVAILABLE( &channelDef, BUF1 ) );
    WMTEST_TRUE( IS_BUFFER_AVAILABLE( &channelDef, BUF2 ) );
}
WMTEST_END

#endif /* WM_TESTING */

#endif /* WM_AUDIO_STREAM */

/*------------------------------ END OF FILE ---------------------------------*/