hwctxt.cpp

Samsung公司S3C6400芯片的BSP源码包

{
	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

		// IIS PCM input enable
		IIS_set_rx_mode_control(IIS_TRANSFER_NOPAUSE);

		DMA_set_channel_source(&g_InputDMA, IIS_get_input_physical_buffer_address(IIS_CH_0), 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);

		IIS_set_active_on();
	}
	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);
		// IIS PCM input disable
		IIS_set_rx_mode_control(IIS_TRANSFER_PAUSE);

		m_InputDMAStatus = DMA_CLEAR;

		if (m_bOutputDMARunning == FALSE) IIS_set_active_off();
	}

	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;

	WAV_INF((_T("[WAV:INF] ++SetOutputMute(%d)\n\r"), bMute));

	m_bOutputMute = bMute;

	CodecReg = ReadCodecRegister(WM8753_DAC_CONTROL);

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

	WriteCodecRegister(WM8753_DAC_CONTROL, CodecReg);

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

	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);
				//WAV_INF((_T("[WAV:INF] InputTransferred = %d\n\r"), InputTransferred));
			}
		}
		__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 IIS Interface SFR
	g_pIISReg = (S3C6400_IIS_REG *)DrvLib_MapIoSpace(S3C6400_BASE_REG_PA_IIS0, sizeof(S3C6400_IIS_REG), FALSE);
	if (g_pIISReg == NULL)
	{
		WAV_ERR((_T("[WAV:ERR] MapRegisters() : g_pIISReg 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_pIISReg != NULL)
	{
		DrvLib_UnmapIoSpace((PVOID)g_pIISReg);
		g_pIISReg = 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::InitIIS()
{
	WAV_MSG((_T("[WAV] ++InitIIS() \n\r")));

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

	return TRUE;
}


BOOL
HardwareContext::InitIISCodec()
{
	DWORD   dwErr = TRUE;
	DWORD   bytes = 0;

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

	if ( m_hI2C == INVALID_HANDLE_VALUE )
	{
		dwErr = GetLastError();
		WAV_ERR((_T("[WAV:ERR] InitIISCodec() : m_hI2C is INVALID_HANDLE_VALUE\n\r")));
		return FALSE;
	}

	I2S_Init8753Driver();

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

	return dwErr;
}


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

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

	if (!g_PhyDMABufferAddr.LowPart)
	{
		WAV_ERR((_T("[WAV:ERR] InitOutputDMA() : DMA Buffer is Not Allocated Yet\n\r")));
		bRet = FALSE;
		goto CleanUp;
	}

	bRet = DMA_request_channel(&g_OutputDMA, DMA_I2S0_TX);
	if (bRet)
	{
		DMA_initialize_channel(&g_OutputDMA, TRUE);
		DMA_set_channel_source(&g_OutputDMA, m_OutputDMABufferPhyPage[0], WORD_UNIT, BURST_1, INCREASE);
		DMA_set_channel_destination(&g_OutputDMA, IIS_get_output_physical_buffer_address(IIS_CH_0), WORD_UNIT, BURST_1, FIXED);
		DMA_set_channel_transfer_size(&g_OutputDMA, AUDIO_DMA_PAGE_SIZE);
		DMA_initialize_LLI(&g_OutputDMA, 2);
		DMA_set_LLI_entry(&g_OutputDMA, 0, LLI_NEXT_ENTRY, m_OutputDMABufferPhyPage[0],
							IIS_get_output_physical_buffer_address(IIS_CH_0), AUDIO_DMA_PAGE_SIZE);
		DMA_set_LLI_entry(&g_OutputDMA, 1, LLI_FIRST_ENTRY, m_OutputDMABufferPhyPage[1],
							IIS_get_output_physical_buffer_address(IIS_CH_0), AUDIO_DMA_PAGE_SIZE);
		DMA_set_initial_LLI(&g_OutputDMA, 1);
	}

CleanUp:

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

	return bRet;
}


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

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

	if (!g_PhyDMABufferAddr.LowPart)
	{
		WAV_ERR((_T("[WAV:ERR] InitInputDMA() : DMA Buffer is Not Allocated Yet\n\r")));
		bRet = FALSE;
		goto CleanUp;
	}

	bRet = DMA_request_channel(&g_InputDMA, DMA_I2S0_RX);
	if (bRet)
	{
		DMA_initialize_channel(&g_InputDMA, TRUE);
		DMA_set_channel_source(&g_InputDMA, IIS_get_input_physical_buffer_address(IIS_CH_0), WORD_UNIT, BURST_1, FIXED);
		DMA_set_channel_destination(&g_InputDMA, m_InputDMABufferPhyPage[0], WORD_UNIT, BURST_1, INCREASE);
		DMA_set_channel_transfer_size(&g_InputDMA, AUDIO_DMA_PAGE_SIZE);
		DMA_initialize_LLI(&g_InputDMA, 2);
		DMA_set_initial_LLI(&g_InputDMA, 1);
		DMA_set_LLI_entry(&g_InputDMA, 0, LLI_NEXT_ENTRY, IIS_get_input_physical_buffer_address(IIS_CH_0),
							m_InputDMABufferPhyPage[0], AUDIO_DMA_PAGE_SIZE);
		DMA_set_LLI_entry(&g_InputDMA, 1, LLI_FIRST_ENTRY, IIS_get_input_physical_buffer_address(IIS_CH_0),
							m_InputDMABufferPhyPage[1], AUDIO_DMA_PAGE_SIZE);
	}

CleanUp:
	WAV_MSG((_T("[WAV] --InitInputDMA()\n\r")));

	return bRet;
}