pingpongdma.cpp

EP931X系列的WinCE声卡驱动源代码

    return(Result);    
}

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


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

    //
    // 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"-PingPongDma::Start\n"));

    return(MMSYSERR_NOERROR);
}

//****************************************************************************
// PingPongDma::Stop
//****************************************************************************
// Stops DMA
// 
//
MMRESULT PingPongDma::Stop(void)
{
    FUNC_DMA((L"+PingPongDma::Stop\n"));
    m_pulDma[M2P_CTRL>>2]      &= ~M2P_CTRL_ENABLE;    
    m_bPlaying = FALSE;         
    Flush();
    //NKDbgPrintfW(L"PingPongDma::Stop.\n");
    FUNC_DMA((L"-PingPongDma::Stop\n"));
    return(MMSYSERR_NOERROR);
}


//****************************************************************************
// PingPongDma::Pause
//****************************************************************************
// Pauses DMA
// 
// return 0 - Success
//        1 - Error
//
MMRESULT PingPongDma::Pause(void)
{
    FUNC_DMA((L"+PingPongDma::Pause\n"));
    m_pulDma[M2P_CTRL>>2]      &= ~M2P_CTRL_ENABLE;    
    //NKDbgPrintfW(L"PingPongDma::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"-PingPongDma::Pause\n"));
    return(MMSYSERR_NOERROR);
}

//****************************************************************************
//  PingPongDma::CurrentPosition
//****************************************************************************
// 
// return 0 - Success
//        1 - Error
//
ULONG PingPongDma::CurrentPosition(void)
{
    ULONG   ulPosition = 0;
    FUNC_DMA((L"+PingPongDma::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"-PingPongDma::CurrentPosition\n"));
    return ulPosition;
}

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

void DelayuS(ULONG ulMicroSec);

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

    while(TRUE)
    {
        WaitForSingleObject(t->m_hEvent, INFINITE);
        
        //
        // 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"PingPongDma::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);
        }

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