pingpongdma.cpp

EP9315开发板的Wince6.0的BSP包文件

//****************************************************************************
// PingPongHwDma::Flush
//****************************************************************************
// Start DMA running
// 
// return 0 - Success
//        1 - Error
//
void PingPongHwDma::Flush(void)
{
    ASSERT(!m_bPlaying);
    m_bOrder                    = 0;
    m_ulCurrentPos              = 0;
}


//****************************************************************************
// PingPongHwDma::Start
//****************************************************************************
// Start DMA running
// 
// return 0 - Success
//        1 - Error
//
MMRESULT PingPongHwDma::Start(void)
{
    FUNC_DMA((L"+PingPongHwDma::Start\n"));
    //NKDbgPrintfW(L"PingPongHwDma::Start.\n");

	if( !m_bPlaying )
	{
		//
		// Check to see if we are at the half buffer point.
		//
		if(m_ulCurrentPos < m_ulBufferSize/2)
		{
			m_pulDma[M2P_MAXCNT0>>2]    = (m_ulBufferSize/2) - m_ulCurrentPos;
			m_pulDma[M2P_MAXCNT1>>2]    = m_ulBufferSize/2;
			m_pulDma[M2P_CTRL>>2]       |= M2P_CTRL_ENABLE;    
			m_pulDma[M2P_BASE0>>2]      = m_ulPhysBuff + m_ulCurrentPos;
			m_pulDma[M2P_BASE1>>2]      = m_ulPhysBuff + m_ulBufferSize/2;
			m_bOrder                    = 0;
		}
		else
		{
			m_pulDma[M2P_MAXCNT1>>2]    = (m_ulBufferSize/2) - m_ulCurrentPos;
			m_pulDma[M2P_MAXCNT0>>2]    = m_ulBufferSize/2;
			m_pulDma[M2P_CTRL>>2]       |= M2P_CTRL_ENABLE;    
			m_pulDma[M2P_BASE1>>2]      = m_ulPhysBuff + m_ulCurrentPos;
			m_pulDma[M2P_BASE0>>2]      = m_ulPhysBuff + m_ulBufferSize/2;
			m_bOrder                    = 1;
		}

		m_bPlaying =  TRUE;

	}

    FUNC_DMA((L"-PingPongHwDma::Start\n"));

    return(MMSYSERR_NOERROR);
}

//****************************************************************************
// PingPongHwDma::Stop
//****************************************************************************
// Stops DMA
// 
//
MMRESULT PingPongHwDma::Stop(void)
{
    FUNC_DMA((L"+PingPongHwDma::Stop\n"));

	if( ! m_bDMANotStop )
	{
		m_pulDma[M2P_CTRL>>2]      &= ~M2P_CTRL_ENABLE;    
		m_bPlaying = FALSE;         
	    Flush();
	}

    FUNC_DMA((L"-PingPongHwDma::Stop\n"));
    return(MMSYSERR_NOERROR);
}


//****************************************************************************
// PingPongHwDma::Pause
//****************************************************************************
// Pauses DMA
// 
// return 0 - Success
//        1 - Error
//
MMRESULT PingPongHwDma::Pause(void)
{
    FUNC_DMA((L"+PingPongHwDma::Pause\n"));
    m_pulDma[M2P_CTRL>>2]      &= ~M2P_CTRL_ENABLE;    
    //NKDbgPrintfW(L"PingPongHwDma::Pause.\n");

    m_bPlaying                  = FALSE; 

    switch(m_pulDma[M2P_STATUS>>2]  & (M2P_STATUS_NEXTBUFFER | M2P_STATUS_CURRSTATE_MASK))
    {
        //
        // Buffer zero is active.
        //
        case  (M2P_STATUS_CURRSTATE_ON | M2P_STATUS_NEXTBUFFER):
        case  (M2P_STATUS_CURRSTATE_IDLE | M2P_STATUS_NEXTBUFFER):
        case  (M2P_STATUS_CURRSTATE_STALL | M2P_STATUS_NEXTBUFFER):
        case  M2P_STATUS_CURRSTATE_NEXT:
        default:
            m_ulCurrentPos =  m_pulDma[M2P_CURRENT0>>2]  - m_ulPhysBuff;
            break;
        //
        // Buffer one is active.
        //
        case  (M2P_STATUS_CURRSTATE_NEXT | M2P_STATUS_NEXTBUFFER):
        case  M2P_STATUS_CURRSTATE_IDLE:
        case  M2P_STATUS_CURRSTATE_STALL:
        case  M2P_STATUS_CURRSTATE_ON:
            m_ulCurrentPos =  m_pulDma[M2P_CURRENT1>>2]  - m_ulPhysBuff;
            break;
    } 


    FUNC_DMA((L"-PingPongHwDma::Pause\n"));
    return(MMSYSERR_NOERROR);
}

//****************************************************************************
//  PingPongHwDma::CurrentPosition
//****************************************************************************
// 
// return 0 - Success
//        1 - Error
//
ULONG PingPongHwDma::CurrentPosition(void)
{
    ULONG   ulPosition = 0;
    FUNC_DMA((L"+PingPongHwDma::CurrentPosition\n"));


    if(m_bPlaying)
    {

        switch(m_pulDma[M2P_STATUS>>2]  & (M2P_STATUS_NEXTBUFFER | M2P_STATUS_CURRSTATE_MASK))
        {
            //
            // Buffer zero is active.
            //
            case (M2P_STATUS_CURRSTATE_ON    | M2P_STATUS_NEXTBUFFER):
            case (M2P_STATUS_CURRSTATE_IDLE  | M2P_STATUS_NEXTBUFFER):
            case (M2P_STATUS_CURRSTATE_STALL | M2P_STATUS_NEXTBUFFER):
            case M2P_STATUS_CURRSTATE_NEXT:
            default:
                ulPosition =  m_pulDma[M2P_CURRENT0>>2]  - m_ulPhysBuff;
                break;
            //
            // Buffer one is active.
            //
            case (M2P_STATUS_CURRSTATE_NEXT | M2P_STATUS_NEXTBUFFER):
            case M2P_STATUS_CURRSTATE_IDLE:
            case M2P_STATUS_CURRSTATE_STALL:
            case M2P_STATUS_CURRSTATE_ON:
                ulPosition =  m_pulDma[M2P_CURRENT1>>2]  - m_ulPhysBuff;
                break;
        } 
    }
    else
    {
        ulPosition = m_ulCurrentPos;
    }

    FUNC_DMA((L"-PingPongHwDma::CurrentPosition\n"));
    return ulPosition;
}

//****************************************************************************
// PingPongHwDma::SetCallBack
//****************************************************************************
// Sets the callback function.
// 
//
//void PingPongHwDma::SetCallBack
//(
//    DMA_PINGPONG_CALLBACK *pfn, 
//    HANDLE hCallBackHandle
//)
//{
//   m_pfnCallBack        = pfn;      
//   m_hCallBackHandle    = hCallBackHandle;
//    
//}

void DelayuS(ULONG ulMicroSec);

//****************************************************************************
// PingPongHwDma::IST
//****************************************************************************
// Interrupt Service thread for the Dma channel.
// 
//
DWORD WINAPI PingPongHwDma::IST(LPVOID lpParameter)
{
    PingPongHwDma *t = (PingPongHwDma *)lpParameter;
    ULONG       ulInterrupt,ulStatus;
    BOOL        bNext;
    ASSERT(t);
    FUNC_DMA((L"+PingPongHwDma::IST\n"));

    while(TRUE)
    {
        WaitForSingleObject(t->m_hEvent, INFINITE);
		//RETAILMSG(1, (TEXT("I")));
        //
        // Check to see if we need to exit the thread.
        //
        if(t->m_bExitThread)
        {
            break;
        }

        //
        // Get the status and interrupt value.
        //
        ulInterrupt = t->m_pulDma[M2P_INT>>2];
        ulStatus    = t->m_pulDma[M2P_STATUS>>2];

        //
        // If a stall occurs, stop and start again.
        //
        if (ulInterrupt & M2P_INT_STALLINT)
        {
            ERRMSG((L"PingPongHwDma::IST Stall has occured.\n"));
            t->m_pulDma[M2P_MAXCNT0>>2]    = t->m_ulBufferSize/2;
            t->m_pulDma[M2P_MAXCNT1>>2]    = t->m_ulBufferSize/2;
            t->m_pulDma[M2P_BASE0>>2]      = t->m_ulPhysBuff;
            t->m_pulDma[M2P_BASE1>>2]      = t->m_ulPhysBuff + t->m_ulBufferSize/2;
            //
            // Clear all pending interrupts by writting a zero.
            //
            //t->m_pulDma[M2P_INTERRUPT>>2] = 0;
            //continue;
        }
        else
        {

            switch (ulStatus & (M2P_STATUS_CURRSTATE_MASK | M2P_STATUS_NEXTBUFFER))
            {
                case (M2P_STATUS_CURRSTATE_ON | M2P_STATUS_NEXTBUFFER):
                case (M2P_STATUS_CURRSTATE_NEXT ):
                    bNext = TRUE;
                    break;    
                case (M2P_STATUS_CURRSTATE_NEXT | M2P_STATUS_NEXTBUFFER):
                case M2P_STATUS_CURRSTATE_ON:
                    bNext = FALSE;
                    break;    
                
                default:                
                    break;
                    PRINTMSG
                    (
                        ZONE_ERROR, 
                        (
                            TEXT("Bad Status value.")
                        )
                    );
            }
        
            if (ulInterrupt & M2P_INT_NFBINT)
            {
                if(t->m_bOrder)
                {
                    if(bNext)
                    {
                        t->m_pulDma[M2P_MAXCNT1>>2]    = t->m_ulBufferSize/2;
                        t->m_pulDma[M2P_BASE1>>2]      = t->m_ulPhysBuff;
                    }
                    else
                    {
                        t->m_pulDma[M2P_MAXCNT0>>2]    = t->m_ulBufferSize/2;
                        t->m_pulDma[M2P_BASE0>>2]      = t->m_ulPhysBuff + t->m_ulBufferSize/2;
                    }                    
                }
                else
                {
                    if(bNext)
                    {
                        t->m_pulDma[M2P_MAXCNT1>>2]    = t->m_ulBufferSize/2;
                        t->m_pulDma[M2P_BASE1>>2]      = t->m_ulPhysBuff + t->m_ulBufferSize/2;
                    }                    
                    else
                    {
                        t->m_pulDma[M2P_MAXCNT0>>2]    = t->m_ulBufferSize/2;
                        t->m_pulDma[M2P_BASE0>>2]      = t->m_ulPhysBuff;
                    }
                }            
            }
        }
        //
        // Call the call back function.
        //
        if(t->m_pfnCallBack && t->m_hCallBackHandle)
        {
            t->m_pfnCallBack(t->m_hCallBackHandle, bNext);
        }

		if( t->m_bPowerOff )
		{
			extern void WavDeviceFreeAllBuffer( void  *  pWaveDevice );
			t->m_bPowerOff=FALSE;

			WavDeviceFreeAllBuffer( t->m_pWaveDevice);
		}

        InterruptDone(t->m_ulSysIntr);
    }
    FUNC_DMA((L"-PingPongHwDma::IST\n"));
    return (0);
}