hwctxt.cpp

Samsung公司S3C6400芯片的BSP源码包

		{
			WAV_ERR((_T("[WAV:ERR] StartOutputDMA() : There is no data to transfer\r\n")));
			m_bOutputDMARunning = FALSE;
		}
	}
	else
	{
		//WAV_ERR((_T("[WAV:ERR] StartOutputDMA() : Output DMA is already running or m_Dx[%d] is not D0\r\n"), m_Dx));
		return FALSE;
	}

	return TRUE;
}


void
HardwareContext::StopOutputDMA()
{
	WAV_MSG((_T("[WAV] StopOutputDMA()\r\n")));

	if (m_bOutputDMARunning)
	{
		m_OutputDMAStatus = DMA_CLEAR;

		// Stop output DMA
		DMA_channel_stop(&g_OutputDMA);

		// AC97 PCM output disable
		AC97_set_pcmout_transfer_mode(AC97_CH_OFF);
	}

	m_bOutputDMARunning = FALSE;

	CodecMuteControl(DMA_CH_OUT, TRUE);
	CodecPowerControl();
}


BOOL
HardwareContext::StartInputDMA()
{

	//WAV_MSG((_T("[WAV] StartInputDMA()\r\n")));

	if(m_bInputDMARunning == FALSE)
	{
		m_bInputDMARunning = TRUE;

		m_nInByte[INPUT_DMA_BUFFER0] = 0;
		m_nInByte[INPUT_DMA_BUFFER1] = 0;

		m_nInputBufferInUse = INPUT_DMA_BUFFER0;	// Start DMA with Buffer 0
		m_InputDMAStatus = (DMA_DONEA | DMA_DONEB) & ~DMA_BIU;

		CodecPowerControl();					// Turn On Channel
		CodecMuteControl(DMA_CH_IN, FALSE);	// Unmute Input Channel

		// AC97 PCM input enable
		AC97_set_pcmin_transfer_mode(AC97_CH_DMA);

		DMA_set_channel_source(&g_InputDMA, AC97_get_pcmin_physical_buffer_address(), WORD_UNIT, BURST_1, FIXED);
		DMA_set_channel_destination(&g_InputDMA, m_InputDMABufferPhyPage[INPUT_DMA_BUFFER0], WORD_UNIT, BURST_1, INCREASE);
		DMA_set_channel_transfer_size(&g_InputDMA, AUDIO_DMA_PAGE_SIZE);
		DMA_set_initial_LLI(&g_InputDMA, 1);
		DMA_channel_start(&g_InputDMA);
	}
	else
	{
		//WAV_ERR((_T("[WAV:ERR] StartInputDMA() : Input DMA is already running\r\n")));
		return FALSE;
	}

	return TRUE;
}


void
HardwareContext::StopInputDMA()
{
	WAV_MSG((_T("[WAV] StopInputDMA()\r\n")));

	if (m_bInputDMARunning)
	{
		DMA_channel_stop(&g_InputDMA);
		AC97_set_pcmin_transfer_mode(AC97_CH_OFF);

		m_InputDMAStatus = DMA_CLEAR;
	}

	m_bInputDMARunning = FALSE;

	CodecMuteControl(DMA_CH_IN, TRUE);
	CodecPowerControl();
}


DWORD
HardwareContext::GetOutputGain (void)
{
    return m_dwOutputGain;
}

MMRESULT
HardwareContext::SetOutputGain (DWORD dwGain)
{
	WAV_MSG((_T("[WAV] SetOutputGain(0x%08x)\r\n"), dwGain));

	m_dwOutputGain = dwGain & 0xffff;	// save off so we can return this from GetGain - but only MONO

	// convert 16-bit gain to 5-bit attenuation
	UCHAR ucGain;
	if (m_dwOutputGain == 0)
	{
		ucGain = 0x3F; // mute: set maximum attenuation
	}
	else
	{
		ucGain = (UCHAR) ((0xffff - m_dwOutputGain) >> 11);	// codec supports 64dB attenuation, we'll only use 32
	}

	//ASSERT((ucGain & 0xC0) == 0); // bits 6,7 clear indicate DATA0 in Volume mode.

	// TODO: When Control HW Volume???

	return MMSYSERR_NOERROR;
}


DWORD
HardwareContext::GetInputGain (void)
{
    return m_dwInputGain;
}

MMRESULT
HardwareContext::SetInputGain (DWORD dwGain)
{
	WAV_MSG((_T("[WAV] SetInputGain(0x%08x)\r\n"), dwGain));

	m_dwInputGain = dwGain;

	if (!m_bInputMute)
	{
		m_InputDeviceContext.SetGain(dwGain);
	}

	return MMSYSERR_NOERROR;
}

BOOL
HardwareContext::GetOutputMute (void)
{
	return m_bOutputMute;
}

MMRESULT
HardwareContext::SetOutputMute (BOOL bMute)
{
	USHORT CodecReg;

	m_bOutputMute = bMute;

	CodecReg = ReadCodecRegister(WM9713_HEADPHONE_VOL);

	if (bMute)
	{
		CodecReg |= 0x8080;
	}
	else
	{
		CodecReg &= ~0x8080;
	}

	WriteCodecRegister(WM9713_HEADPHONE_VOL, CodecReg);

	return MMSYSERR_NOERROR;
}


BOOL
HardwareContext::GetInputMute (void)
{
	return m_bInputMute;
}

MMRESULT
HardwareContext::SetInputMute (BOOL bMute)
{
	m_bInputMute = bMute;
	return m_InputDeviceContext.SetGain(bMute ? 0: m_dwInputGain);
}


DWORD
HardwareContext::ForceSpeaker(BOOL bForceSpeaker)
{
	// If m_NumForcedSpeaker is non-zero, audio should be routed to an
	// external speaker (if hw permits).
	if (bForceSpeaker)
	{
		m_NumForcedSpeaker++;
		if (m_NumForcedSpeaker == 1)
		{
			SetSpeakerEnable(TRUE);
		}
	}
	else
	{
		m_NumForcedSpeaker--;
		if (m_NumForcedSpeaker ==0)
		{
			SetSpeakerEnable(FALSE);
		}
	}

	return MMSYSERR_NOERROR;
}


void
HardwareContext::InterruptThreadOutputDMA()
{
	ULONG OutputTransferred;

#if (_WIN32_WCE < 600)
	// Fast way to access embedded pointers in wave headers in other processes.
	SetProcPermissions((DWORD)-1);
#endif

	WAV_INF((_T("[WAV:INF] ++InterruptThreadOutputDMA()\n\r")));

	while(TRUE)
	{
		WaitForSingleObject(m_hOutputDMAInterrupt, INFINITE);

		Lock();

		__try
		{
			DMA_set_interrupt_mask(&g_OutputDMA);
			DMA_clear_interrupt_pending(&g_OutputDMA);

			InterruptDone(m_dwSysintrOutput);

			DMA_clear_interrupt_mask(&g_OutputDMA);

			if ( m_Dx == D0 )
			{
				// DMA Output Buffer is Changed by LLI
				if (m_nOutputBufferInUse == OUTPUT_DMA_BUFFER0)
				{
					// Buffer0 DMA finished
					// DMA start with Buffer 1
					m_nOutputBufferInUse = OUTPUT_DMA_BUFFER1;
				}
				else
				{
					// Buffer 1 DMA finished
					// DMA start with Buffer 0
					m_nOutputBufferInUse = OUTPUT_DMA_BUFFER0;
				}

				if(m_OutputDMAStatus & DMA_BIU)
				{
					m_OutputDMAStatus &= ~DMA_STRTB;	// Buffer B just completed...
					m_OutputDMAStatus |= DMA_DONEB;
					m_OutputDMAStatus &= ~DMA_BIU;		// Buffer A is in use
				}
				else
				{
					m_OutputDMAStatus &= ~DMA_STRTA;	// Buffer A just completed...
					m_OutputDMAStatus |= DMA_DONEA;
					m_OutputDMAStatus |= DMA_BIU;		// Buffer B is in use
				}

				OutputTransferred = TransferOutputBuffer(m_OutputDMAStatus);
			}
		}
		__except(EXCEPTION_EXECUTE_HANDLER)
		{
			DEBUGMSG(ZONE_ERROR, (TEXT("WAVDEV2.DLL:InterruptThreadOutputDMA() - EXCEPTION: %d"), GetExceptionCode()));
		}

		Unlock();
	}

	WAV_INF((_T("[WAV:INF] --InterruptThreadOutputDMA()\n\r")));
}

void
HardwareContext::InterruptThreadInputDMA()
{
	ULONG InputTransferred;		// How can I use it ???

#if (_WIN32_WCE < 600)
	// Fast way to access embedded pointers in wave headers in other processes.
	SetProcPermissions((DWORD)-1);
#endif

	WAV_INF((_T("[WAV:INF] ++InterruptThreadInputDMA()\n\r")));

	while(TRUE)
	{
		WaitForSingleObject(m_hInputDMAInterrupt, INFINITE);

		Lock();

		__try
		{
			DMA_set_interrupt_mask(&g_InputDMA);
			DMA_clear_interrupt_pending(&g_InputDMA);

			InterruptDone(m_dwSysintrInput);

			DMA_clear_interrupt_mask(&g_InputDMA);

			if ( m_Dx == D0 )
			{
				if (m_nInputBufferInUse == INPUT_DMA_BUFFER0)
				{
					// Buffer0 DMA finished
					// DMA start with Buffer 1
					m_nInputBufferInUse = INPUT_DMA_BUFFER1;
				}
				else
				{
					// Buffer 1 DMA finished
					// DMA start with Buffer 0
					m_nInputBufferInUse = INPUT_DMA_BUFFER0;
				}

				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
				}
				else
				{
					m_InputDMAStatus &= ~DMA_STRTA;		// Buffer A just completed...
					m_InputDMAStatus |= DMA_DONEA;
					m_InputDMAStatus |= DMA_BIU;			// Buffer B is in use
				}

				InputTransferred = TransferInputBuffers(m_InputDMAStatus);
			}
		}
		__except(EXCEPTION_EXECUTE_HANDLER)
		{
			DEBUGMSG(ZONE_ERROR, (TEXT("WAVDEV2.DLL:InterruptThreadInputDMA() - EXCEPTION: %d"), GetExceptionCode()));
		}

		Unlock();
	}

	WAV_INF((_T("[WAV:INF] --InterruptThreadInputDMA()\n\r")));
}



BOOL
HardwareContext::MapRegisters()
{
	BOOL bRet = TRUE;

	WAV_MSG((_T("[WAV] ++MapRegisters()\n\r")));

	// Alloc and Map GPIO SFR
	g_pGPIOReg = (S3C6400_GPIO_REG *)DrvLib_MapIoSpace(S3C6400_BASE_REG_PA_GPIO, sizeof(S3C6400_GPIO_REG), FALSE);
	if (g_pGPIOReg == NULL)
	{
		WAV_ERR((_T("[WAV:ERR] MapRegisters() : g_pGPIOReg DrvLib_MapIoSpace() Failed\n\r")));
		bRet = FALSE;
		goto CleanUp;
	}

	// Alloc and Map DMAC0 SFR
	g_pDMAC0Reg = (S3C6400_DMAC_REG *)DrvLib_MapIoSpace(S3C6400_BASE_REG_PA_DMA0, sizeof(S3C6400_DMAC_REG), FALSE);
	if (g_pDMAC0Reg == NULL)
	{
		WAV_ERR((_T("[WAV:ERR] MapRegisters() : g_pDMAC0Reg DrvLib_MapIoSpace() Failed\n\r")));
		bRet = FALSE;
		goto CleanUp;
	}

	// Alloc and Map DMAC1 SFR
	g_pDMAC1Reg = (S3C6400_DMAC_REG *)DrvLib_MapIoSpace(S3C6400_BASE_REG_PA_DMA1, sizeof(S3C6400_DMAC_REG), FALSE);
	if (g_pDMAC1Reg == NULL)
	{
		WAV_ERR((_T("[WAV:ERR] MapRegisters() : g_pDMAC1Reg DrvLib_MapIoSpace() Failed\n\r")));
		bRet = FALSE;
		goto CleanUp;
	}

	// Alloc and Map AC97 Interface SFR
	g_pAC97Reg = (S3C6400_AC97_REG *)DrvLib_MapIoSpace(S3C6400_BASE_REG_PA_AC97, sizeof(S3C6400_AC97_REG), FALSE);
	if (g_pAC97Reg == NULL)
	{
		WAV_ERR((_T("[WAV:ERR] MapRegisters() : g_pAC97Reg DrvLib_MapIoSpace() Failed\n\r")));
		bRet = FALSE;
		goto CleanUp;
	}

	// Alloc and Map System Controller SFR
	g_pSysConReg = (S3C6400_SYSCON_REG *)DrvLib_MapIoSpace(S3C6400_BASE_REG_PA_SYSCON, sizeof(S3C6400_SYSCON_REG), FALSE);
	if (g_pSysConReg == NULL)
	{
		WAV_ERR((_T("[WAV:ERR] MapRegisters() : g_pSysConReg DrvLib_MapIoSpace() Failed\n\r")));
		bRet = FALSE;
		goto CleanUp;
	}

CleanUp:

	if (bRet == FALSE)
	{
		UnMapRegisters();
	}

	WAV_MSG((_T("[WAV] --MapRegisters()\n\r")));

	return(TRUE);
}


BOOL
HardwareContext::UnMapRegisters()
{
	WAV_MSG((_T("[WAV] UnMapRegisters()\n\r")));

	if (g_pGPIOReg != NULL)
	{
		DrvLib_UnmapIoSpace((PVOID)g_pGPIOReg);
		g_pGPIOReg = NULL;
	}

	if (g_pAC97Reg != NULL)
	{
		DrvLib_UnmapIoSpace((PVOID)g_pAC97Reg);
		g_pAC97Reg = NULL;
	}

	if (g_pDMAC0Reg != NULL)
	{
		DrvLib_UnmapIoSpace((PVOID)g_pDMAC0Reg);
		g_pDMAC0Reg = NULL;
	}

	if (g_pDMAC1Reg != NULL)
	{
		DrvLib_UnmapIoSpace((PVOID)g_pDMAC1Reg);
		g_pDMAC1Reg = NULL;
	}

	if (g_pSysConReg != NULL)
	{
		DrvLib_UnmapIoSpace((PVOID)g_pSysConReg);
		g_pSysConReg = NULL;
	}

	return TRUE;
}


BOOL
HardwareContext::MapDMABuffers()
{
	PVOID pVirtDMABufferAddr = NULL;
	DMA_ADAPTER_OBJECT Adapter;
	BOOL bRet = TRUE;

	WAV_MSG((_T("[WAV] ++MapDMABuffers()\n\r")));

	memset(&Adapter, 0, sizeof(DMA_ADAPTER_OBJECT));
	Adapter.ObjectSize = sizeof(DMA_ADAPTER_OBJECT);
	Adapter.InterfaceType = Internal;

	// Allocate DMA Buffer
	pVirtDMABufferAddr = HalAllocateCommonBuffer(&Adapter, AUDIO_DMA_BUFFER_SIZE, &g_PhyDMABufferAddr, FALSE);
	if (pVirtDMABufferAddr == NULL)
	{
		WAV_MSG((_T("[WAV:ERR] MapDMABuffers() : DMA Buffer Allocation Failed\n\r")));
		bRet = FALSE;
		goto CleanUp;
	}

	// Setup the Physical Address of DMA Buffer Page Address
	m_OutputDMABufferPhyPage[0] = (UINT32)g_PhyDMABufferAddr.LowPart;
	m_OutputDMABufferPhyPage[1] = (UINT32)(g_PhyDMABufferAddr.LowPart+AUDIO_DMA_PAGE_SIZE);
	m_InputDMABufferPhyPage[0] = (UINT32)(g_PhyDMABufferAddr.LowPart+AUDIO_DMA_PAGE_SIZE*2);
	m_InputDMABufferPhyPage[1] = (UINT32)(g_PhyDMABufferAddr.LowPart+AUDIO_DMA_PAGE_SIZE*3);

	// Setup the Virtual Address of DMA Buffer Page Address
	m_OutputDMABufferVirPage[0] = (PBYTE)pVirtDMABufferAddr;
	m_OutputDMABufferVirPage[1] = (PBYTE)((UINT32)pVirtDMABufferAddr+AUDIO_DMA_PAGE_SIZE);
	m_InputDMABufferVirPage[0] = (PBYTE)((UINT32)pVirtDMABufferAddr+AUDIO_DMA_PAGE_SIZE*2);
	m_InputDMABufferVirPage[1] = (PBYTE)((UINT32)pVirtDMABufferAddr+AUDIO_DMA_PAGE_SIZE*3);

CleanUp:

	WAV_MSG((_T("[WAV] --MapDMABuffers() : %d\n\r"), bRet));

	return bRet;
}


BOOL
HardwareContext::UnMapDMABuffers()
{
	WAV_MSG((_T("[WAV] UnMapDMABuffers()\n\r")));

	if(m_OutputDMABufferVirPage[0])
	{
		PHYSICAL_ADDRESS PhysicalAddress;
		PhysicalAddress.LowPart = m_OutputDMABufferPhyPage[0];	// No Meaning just for compile

		HalFreeCommonBuffer(0, 0, PhysicalAddress, (PVOID)m_OutputDMABufferVirPage[0], FALSE);

		m_OutputDMABufferVirPage[0] = NULL;
		m_OutputDMABufferVirPage[1] = NULL;
		m_InputDMABufferVirPage[0] = NULL;
		m_InputDMABufferVirPage[1] = NULL;
	}

	return TRUE;
}


BOOL
HardwareContext::InitAC97()
{
	WAV_MSG((_T("[WAV] ++InitAC97() \n\r")));

	AC97_initialize_ACLink();