hwctxt.cpp

SMDK2450的BSP 有很多新的特性,记得升级PB啊.

    PBYTE pBufferStart = m_Input_pbDMA_PAGES[NumBuf];
    PBYTE pBufferEnd = pBufferStart + AUDIO_DMA_PAGE_SIZE;
    PBYTE pBufferLast;

	RETAILMSG(AC97_DEBUG3,(_T("TransferInputBuffer:%d\r\n"),NumBuf));
	__try
	{
		pBufferLast = m_InputDeviceContext.TransferBuffer(pBufferStart, pBufferEnd,NULL);
		BytesTransferred = m_InBytes[NumBuf] = pBufferLast-pBufferStart;
		if(NumBuf == IN_BUFFER_A)			// Input Buffer A
		{
			m_InputDMAStatus &= ~DMA_DONEA;
			m_InputDMAStatus |= DMA_STRTA;
		}
		else								// Input Buffer B
		{
			m_InputDMAStatus &= ~DMA_DONEB;
			m_InputDMAStatus |= DMA_STRTB;
		}

	}
	__except(EXCEPTION_EXECUTE_HANDLER) 
	{
		DEBUGMSG(ZONE_ERROR, (TEXT("WAVDEV2.DLL:TransferInputBuffer() - EXCEPTION: %d"), GetExceptionCode()));
	}

    return BytesTransferred;
}


/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Function:		TransferInputBuffers()

Description:	Determines which input buffer (A or B) needs to 
				be filled with recorded sound data.  The correct 
				buffer is then populated with recorded sound data
				from the input channel.

Returns:		Boolean indicating success
-------------------------------------------------------------------*/
ULONG HardwareContext::TransferInputBuffers(DWORD dwDCSR)
{
    ULONG BytesTransferred=0;
    DWORD Bits = dwDCSR & (DMA_DONEA|DMA_DONEB|DMA_BIU);

	RETAILMSG(AC97_DEBUG3,(_T("TransferInputBuffers:%d\r\n"),Bits));
    switch (Bits)
    {
    case 0:
    case DMA_BIU:
        // No done bits set- must not be my interrupt
        return 0;
    case DMA_DONEA|DMA_DONEB|DMA_BIU:
        // Load B, then A
        BytesTransferred = TransferInputBuffer(IN_BUFFER_B);
        // fall through
    case DMA_DONEA: // This should never happen!
    case DMA_DONEA|DMA_BIU:
        // Load A
        BytesTransferred += TransferInputBuffer(IN_BUFFER_A);
        break;
    case DMA_DONEA|DMA_DONEB:
        // Load A, then B
        BytesTransferred = TransferInputBuffer(IN_BUFFER_A);
		BytesTransferred += TransferInputBuffer(IN_BUFFER_B);
		break;
        // fall through
    case DMA_DONEB|DMA_BIU: // This should never happen!
    case DMA_DONEB:
        // Load B
        BytesTransferred += TransferInputBuffer(IN_BUFFER_B);
        break;
    }

    // If it was our interrupt, but we weren't able to transfer any bytes
    // (e.g. no empty buffers ready to be filled)
    // Then stop the input DMA
    if (BytesTransferred==0)
    {
        StopInputDMA();
    }
#if (BSP_TYPE == BSP_SMDK2443)
#elif (BSP_TYPE == BSP_SMDK2450)
	else
	{
		StartInputDMA();		// for DMA resume when wake up
	}
#endif
    return BytesTransferred;
}


void HardwareContext::InterruptThreadInput()
{
    ULONG InputTransferred;
	BOOL dmaInterruptSource = 0;

    // Fast way to access embedded pointers in wave headers in other processes.
	SetProcPermissions((DWORD)-1);

    while(TRUE)
    {
		WaitForSingleObject(m_hAudioInterruptInput, INFINITE);
        RETAILMSG(AC97_DEBUG,(_T("InterruptThread\r\n")));	
		dmaInterruptSource = 0;
		//----- 1. Grab the lock -----
		//Lock();

		__try
		{

			InterruptDone(m_dwSysintrInput);
			
#if (BSP_TYPE == BSP_SMDK2443)
			if ( m_Dx != D0 ) continue;
#elif (BSP_TYPE == BSP_SMDK2450)
			if ( m_Dx == D0 ){
#endif
						
           
            //----- 4. Handle any interrupts on the input source -----
			//		   NOTE: The InterruptDone() call below automatically clears the interrupt.

			//----- Determine which buffer just completed the DMA transfer -----
			if(m_InputDMAStatus & DMA_BIU)
			{
				m_InputDMAStatus &= ~DMA_STRTB;							// Buffer B just completed...
				m_InputDMAStatus |= DMA_DONEB;

				m_InputDMAStatus &= ~DMA_BIU;							// Buffer A is in use


///////////////////////////////////		
				UINT32 delay_count1;			
				delay_count1 = 0;
				while((v_pDMAregs->DSTAT2&0xfffff)==0){
#if WAIT_DMA_END
					Sleep(1);
#else						
        			if( delay_count1++ > DELAY_COUNT )	break;
#endif						
        		} 	
//////////////////////////////////		Added by JJG 07.03.04	        		
        							
#if DMA_FLAG					
				SELECT_AUDIO_DMA_INPUT_BUFFER_B();
#else					
				SELECT_AUDIO_DMA_INPUT_BUFFER_A();
#endif
				RETAILMSG(AC97_DEBUG,(_T("In1\r\n")));	
			}else
			{
				m_InputDMAStatus &= ~DMA_STRTA;							// Buffer A just completed...
				m_InputDMAStatus |= DMA_DONEA;

				m_InputDMAStatus |= DMA_BIU;							// Buffer B is in use
				
///////////////////////////////////		
				UINT32 delay_count1;				
				delay_count1 = 0;
				while((v_pDMAregs->DSTAT2&0xfffff)==0){
#if WAIT_DMA_END
					Sleep(1);
#else						
        			if( delay_count1++ > DELAY_COUNT )	break;
#endif						
        		} 
//////////////////////////////////		Added by JJG 07.03.04
        							
#if DMA_FLAG
				SELECT_AUDIO_DMA_INPUT_BUFFER_A();
#else										
				SELECT_AUDIO_DMA_INPUT_BUFFER_B();
#endif	
				RETAILMSG(AC97_DEBUG,(_T("In2\r\n")));	
			}
#if !DMA_FLAG		
			//----- 5. Schedule the next DMA transfer -----
			AUDIO_IN_DMA_ENABLE();
#endif					
			//----- 6. Retrieve the next chunk of recorded data from the non-playing buffer -----
			InputTransferred = TransferInputBuffers(m_InputDMAStatus);			
#if (BSP_TYPE == BSP_SMDK2443)
#elif (BSP_TYPE == BSP_SMDK2450)
			}
#endif
		}
		__except(EXCEPTION_EXECUTE_HANDLER) 
		{
			DEBUGMSG(ZONE_ERROR, (TEXT("WAVDEV2.DLL:InterruptThread() - EXCEPTION: %d"), GetExceptionCode()));
		}

		//----- 10. Give up the lock ----- 
		//Unlock();
	}  
}


void HardwareContext::InterruptThreadOutput()
{
    ULONG OutputTransferred;
	BOOL dmaInterruptSource = 0;

    // Fast way to access embedded pointers in wave headers in other processes.
	SetProcPermissions((DWORD)-1);

    while(TRUE)
    {
		WaitForSingleObject(m_hAudioInterruptOutput, INFINITE);
        RETAILMSG(AC97_DEBUG,(_T("InterruptThread\r\n")));	
		dmaInterruptSource = 0;
		//----- 1. Grab the lock -----
		//Lock();

		__try
		{


			InterruptDone(m_dwSysintrOutput);

#if (BSP_TYPE == BSP_SMDK2443)
			if ( m_Dx != D0 ) continue;
#elif (BSP_TYPE == BSP_SMDK2450)
			if ( m_Dx == D0 ){
#endif


			//----- 7. Handle any interrupts on the output source -----
			//		   NOTE: The InterruptDone() call below automatically clears the interrupt.
	
			//----- Determine which buffer just completed the DMA transfer -----
			if(m_OutputDMAStatus & DMA_BIU)
			{
				m_OutputDMAStatus &= ~DMA_STRTB;						// Buffer A just completed...
				m_OutputDMAStatus |= DMA_DONEB;

				m_OutputDMAStatus &= ~DMA_BIU;							// Buffer B is in use
				UINT32 delay_count2;
				delay_count2 = 0;
				while((v_pDMAregs->DSTAT1&0xfffff)==0){
#if WAIT_DMA_END
					Sleep(1);
#else						
        			if( delay_count2++ > DELAY_COUNT )	break;
#endif						
        		} 						
				RETAILMSG(AC97_DEBUG2,(_T("Out1\r\n")));	
#if DMA_FLAG		
				SELECT_AUDIO_DMA_OUTPUT_BUFFER_B();		// charlie. B => A
#else				
				SELECT_AUDIO_DMA_OUTPUT_BUFFER_A();		// charlie. B => A	
#endif	
			}else
			{
				m_OutputDMAStatus &= ~DMA_STRTA;						// Buffer B just completed...
				m_OutputDMAStatus |= DMA_DONEA;

				m_OutputDMAStatus |= DMA_BIU;							// Buffer A is in use
				UINT32 delay_count2;
				delay_count2 = 0;			
				while((v_pDMAregs->DSTAT1&0xfffff)==0){
#if WAIT_DMA_END
					Sleep(1);
#else						
        			if( delay_count2++ > DELAY_COUNT )	break;
#endif						
        		}						
				RETAILMSG(AC97_DEBUG2,(_T("Out2\r\n")));	
#if DMA_FLAG					
				SELECT_AUDIO_DMA_OUTPUT_BUFFER_A();		// charlie. B => A
#else				
				SELECT_AUDIO_DMA_OUTPUT_BUFFER_B();		// charlie. B => A	
#endif	
			}
#if !DMA_FLAG		
			//----- 8. Schedule the next DMA transfer -----
			AUDIO_OUT_DMA_ENABLE();
#endif
			//----- 9. Fill the non-playing buffer with the next chunk of audio data to play -----
			OutputTransferred = TransferOutputBuffers(m_OutputDMAStatus);			
#if (BSP_TYPE == BSP_SMDK2443)
#elif (BSP_TYPE == BSP_SMDK2450)
			}
#endif
		}
		__except(EXCEPTION_EXECUTE_HANDLER) 
		{
			DEBUGMSG(ZONE_ERROR, (TEXT("WAVDEV2.DLL:InterruptThread() - EXCEPTION: %d"), GetExceptionCode()));
		}

		//----- 10. Give up the lock ----- 
		//Unlock();
	}  
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Function:		AudioMute()

Description:	Mutes/unmutes the specified audio channel.

Notes:			If both audio channels are MUTED, then the chip 
				is powered down to conserve battery life.  
				Alternatively, if either audio channel is unMUTED, 
				the chip is powered up.

Returns:		Boolean indicating success
-------------------------------------------------------------------*/
BOOL HardwareContext::AudioMute(DWORD channel, BOOL bMute)
{
	static DWORD dwActiveChannel = 0;
	USHORT volume;

	Lock();
	// 
	// Turn off/on mute bit in volume control register.
	//
#if (BSP_TYPE == BSP_SMDK2443)
	if( (channel & DMA_CH_OUT ))		// 030711
	{
		if(bMute)
		{
			volume = ReadCodecRegister(AC97_HEADPHONE_VOL);
   			WriteCodecRegister(AC97_HEADPHONE_VOL, volume | 0x8000);
		}
		else
		{
			volume = ReadCodecRegister(AC97_HEADPHONE_VOL);
   			WriteCodecRegister(AC97_HEADPHONE_VOL, volume & ~0x8000);
		}
	}		

#if AC97_RECORD_MICIN
	if( (channel & DMA_CH_MIC ) )
	{
		if(bMute)
		{
			volume = ReadCodecRegister(AC97_MIC_VOL);
     		WriteCodecRegister(AC97_MIC_VOL, volume | 0x8000);
		}
		else
		{
			volume = ReadCodecRegister(AC97_MIC_VOL);
     		WriteCodecRegister(AC97_MIC_VOL, volume & ~0x8000);
		}
	}		
#else
	if( (channel & DMA_CH_MIC ))
	{
		if(bMute)
		{
			volume = ReadCodecRegister(AC97_LINEIN_VOL);
     		WriteCodecRegister(AC97_LINEIN_VOL, volume | 0x8000);
		}
		else
		{
			volume = ReadCodecRegister(AC97_LINEIN_VOL);
     		WriteCodecRegister(AC97_LINEIN_VOL, volume & ~0x8000);
		}
	}
#endif
#elif (BSP_TYPE == BSP_SMDK2450)
	if( (channel & DMA_CH_OUT ))
	{
		if(bMute)
		{
			volume = ReadCodecRegister(AC97_HEADPHONE_VOL);
   			WriteCodecRegister(WM9713_HEADPHONE_VOL, volume | 0x8080);
		}
		else
		{
			volume = ReadCodecRegister(AC97_HEADPHONE_VOL);
   			WriteCodecRegister(WM9713_HEADPHONE_VOL, volume & ~0x8080);
		}
	}		

#if AC97_RECORD_MICIN
	if( (channel & DMA_CH_MIC ) )
	{
		if(bMute)
		{
			volume = ReadCodecRegister(WM9713_MIC_VOL);
     		WriteCodecRegister(WM9713_MIC_VOL, volume | 0x8000);
		}
		else
		{
			volume = ReadCodecRegister(WM9713_MIC_VOL);
     		WriteCodecRegister(WM9713_MIC_VOL, volume & ~0x8000);
		}
	}		
#else
	if( (channel & DMA_CH_MIC ))
	{
		if(bMute)
		{
			volume = ReadCodecRegister(WM9713_LINEIN_VOL_ROUTING);
     		WriteCodecRegister(WM9713_LINEIN_VOL_ROUTING, volume | 0xe000);
		}
		else
		{
			volume = ReadCodecRegister(WM9713_LINEIN_VOL_ROUTING);
     		WriteCodecRegister(WM9713_LINEIN_VOL_ROUTING, volume & ~0xe000);
		}
	}
#endif
#endif
	Unlock();
	return(TRUE);
}


void CallInterruptThreadInput(HardwareContext *pHWContext)
{
    pHWContext->InterruptThreadInput();
}

void CallInterrupt