s3c6400_display_con.c

Samsung公司S3C6400芯片的BSP源码包

	}

	g_Win1Config.BPP_Mode = BPPMode;
	g_Win1Config.BufferSelect = BUFSEL_BUF0;
	g_Win1Config.BufferAutoControl = BUFAUTO_DISABLE;
	g_Win1Config.uiWidth = uiWidth;
	g_Win1Config.uiHeight = uiHeight;
	g_Win1Config.uiOffsetX = uiOffsetX;
	g_Win1Config.uiOffsetY = uiOffsetY;

	if (g_Win1Config.uiPageWidth%4)
	{
		DISP_ERR((_T("[DISP:ERR] Disp_window1_initialize() : uiPageWidth is not Word Aligned [%d]\n\r"), g_Win0Config.uiPageWidth));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
	}
	else if (g_Win1Config.uiPageWidth >= 16*4)
	{
		g_Win1Config.BurstLength = BURSTLEN_16WORD;
	}
	else if (g_Win1Config.uiPageWidth >= 8*4)
	{
		g_Win1Config.BurstLength = BURSTLEN_8WORD;
	}
	else
	{
		g_Win1Config.BurstLength = BURSTLEN_4WORD;
	}

	g_pDispConReg->WINCON1 = CSC_WIDE_RANGE | g_Win1Config.LocalPathSelect | //g_Win1Config.LocalPathEnable |
							g_Win1Config.BufferSelect | g_Win1Config.BufferAutoControl | g_Win1Config.BitSwapping |
							g_Win1Config.ByteSwapping | g_Win1Config.HalfWordSwapping | g_Win1Config.LocaPathSourceFormat |
							g_Win1Config.BurstLength | BLEND_PER_PLANE | BPPMODE_F(g_Win1Config.BPP_Mode) |
							ALPHASEL_ALPHA0;

	g_pDispConReg->VIDOSD1A = OSD_LEFTTOPX_F(g_Win1Config.uiOffsetX) | OSD_LEFTTOPY_F(g_Win1Config.uiOffsetY);

	g_pDispConReg->VIDOSD1B = OSD_RIGHTBOTX_F(g_Win1Config.uiWidth+g_Win1Config.uiOffsetX-1) |
								OSD_RIGHTBOTY_F(g_Win1Config.uiHeight+g_Win1Config.uiOffsetY-1);

	g_pDispConReg->VIDOSD1C = 0x0;

	g_pDispConReg->VIDOSD1D = OSD_SIZE(g_Win1Config.uiWidth*g_Win1Config.uiHeight);

	DISP_MSG((_T("[DISP]--Disp_window1_initialize() : %d\n\r"), error));

	return error;
}

static DISP_ERROR Disp_window2_initialize(DISP_WINDOW_MODE Mode, DISP_BPP_MODE BPPMode, unsigned int uiWidth, unsigned int uiHeight, unsigned int uiOffsetX, unsigned int uiOffsetY)
{
	DISP_ERROR error = DISP_SUCCESS;

	DISP_MSG((_T("[DISP]++Disp_window2_initialize(%d, %d, %d, %d, %d, %d)\n\r"), Mode, BPPMode, uiWidth, uiHeight, uiOffsetX, uiOffsetY));

	switch(Mode)
	{
	case DISP_WIN2_DMA:
		g_Win2Config.LocalPathEnable = LOCAL_PATH_DISABLE;
		//g_Win2Config.LocalPathSelect;			// Don't care when Local Path is disabled
		//g_Win2Config.LocaPathSourceFormat;	// Don't care when Local Path is disabled
		break;
	case DISP_WIN2_TVSCALER_RGB:
		g_Win2Config.LocalPathEnable = LOCAL_PATH_ENABLE;
		g_Win2Config.LocalPathSelect = LOCALSEL_TVSCALER;
		g_Win2Config.LocaPathSourceFormat = LOCAL_IN_RGB888;
		break;
	case DISP_WIN2_TVSCALER_YUV:
		g_Win2Config.LocalPathEnable = LOCAL_PATH_ENABLE;
		g_Win2Config.LocalPathSelect = LOCALSEL_TVSCALER;
		g_Win2Config.LocaPathSourceFormat = LOCAL_IN_YUV444;
		break;
	case DISP_WIN2_CICODEC_RGB:
		g_Win2Config.LocalPathEnable = LOCAL_PATH_ENABLE;
		g_Win2Config.LocalPathSelect = LOCALSEL_CIPREVIEW;
		g_Win2Config.LocaPathSourceFormat = LOCAL_IN_RGB888;
		break;
	case DISP_WIN2_CICODEC_YUV:
		g_Win2Config.LocalPathEnable = LOCAL_PATH_ENABLE;
		g_Win2Config.LocalPathSelect = LOCALSEL_CIPREVIEW;
		g_Win2Config.LocaPathSourceFormat = LOCAL_IN_YUV444;
		break;
	default:
		DISP_ERR((_T("[DISP:ERR] Disp_window2_initialize() : Unsupported Window Mode [%d]\n\r"), Mode));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
		break;
	}

	g_Win2Config.BitSwapping = BITSWP_DISABLE;
	g_Win2Config.ByteSwapping = BYTSWP_DISABLE;
	g_Win2Config.HalfWordSwapping = HAWSWP_DISABLE;

	switch(BPPMode)
	{
	//case DISP_1BPP:
	//case DISP_2BPP:
	//case DISP_4BPP:
	//case DISP_8BPP_NOPAL:
	//case DISP_16BPP_A555:
	//case DISP_16BPP_I555:
	//case DISP_18BPP_A665:
	//case DISP_19BPP_A666:
	//case DISP_24BPP_A887:
	//case DISP_25BPP_A888:
	case DISP_16BPP_565:
		g_Win2Config.uiPageWidth = uiWidth*2;	// 2 byte per pixel
		g_Win2Config.HalfWordSwapping = HAWSWP_ENABLE;	// 16BPP need Halfword Swapping
		break;
	case DISP_18BPP_666:
	case DISP_24BPP_888:
		g_Win2Config.uiPageWidth = uiWidth*4;	// 4 byte per pixel
		break;
	default:
		DISP_ERR((_T("[DISP:ERR] Disp_window2_initialize() : Unsupported BPP Mode [%d]\n\r"), BPPMode));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
		break;
	}

	g_Win2Config.BPP_Mode = BPPMode;
	g_Win2Config.BufferSelect = BUFSEL_BUF0;
	g_Win2Config.BufferAutoControl = BUFAUTO_DISABLE;
	g_Win2Config.uiWidth = uiWidth;
	g_Win2Config.uiHeight = uiHeight;
	g_Win2Config.uiOffsetX = uiOffsetX;
	g_Win2Config.uiOffsetY = uiOffsetY;

	if (g_Win2Config.uiPageWidth%4)
	{
		DISP_ERR((_T("[DISP:ERR] Disp_window2_initialize() : uiPageWidth is not Word Aligned [%d]\n\r"), g_Win0Config.uiPageWidth));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
	}
	else if (g_Win2Config.uiPageWidth >= 16*4)
	{
		g_Win2Config.BurstLength = BURSTLEN_16WORD;
	}
	else if (g_Win2Config.uiPageWidth >= 8*4)
	{
		g_Win2Config.BurstLength = BURSTLEN_8WORD;
	}
	else
	{
		g_Win2Config.BurstLength = BURSTLEN_4WORD;
	}

	g_pDispConReg->WINCON2 = CSC_WIDE_RANGE | g_Win2Config.LocalPathSelect | //g_Win2Config.LocalPathEnable |
							g_Win2Config.BufferSelect | g_Win2Config.BufferAutoControl | g_Win2Config.BitSwapping |
							g_Win2Config.ByteSwapping | g_Win2Config.HalfWordSwapping | g_Win2Config.LocaPathSourceFormat |
							g_Win2Config.BurstLength | BLEND_PER_PLANE | BPPMODE_F(g_Win2Config.BPP_Mode) |
							ALPHASEL_ALPHA0;

	g_pDispConReg->VIDOSD2A = OSD_LEFTTOPX_F(g_Win2Config.uiOffsetX) | OSD_LEFTTOPY_F(g_Win2Config.uiOffsetY);

	g_pDispConReg->VIDOSD2B = OSD_RIGHTBOTX_F(g_Win2Config.uiWidth+g_Win2Config.uiOffsetX-1) |
								OSD_RIGHTBOTY_F(g_Win2Config.uiHeight+g_Win2Config.uiOffsetY-1);

	g_pDispConReg->VIDOSD2C = 0x0;

	g_pDispConReg->VIDOSD2D = OSD_SIZE(g_Win2Config.uiWidth*g_Win2Config.uiHeight);

	DISP_MSG((_T("[DISP]--Disp_window2_initialize() : %d\n\r"), error));

	return error;
}

static DISP_ERROR Disp_window3_initialize(DISP_WINDOW_MODE Mode, DISP_BPP_MODE BPPMode, unsigned int uiWidth, unsigned int uiHeight, unsigned int uiOffsetX, unsigned int uiOffsetY)
{
	DISP_ERROR error = DISP_SUCCESS;

	DISP_MSG((_T("[DISP]++Disp_window3_initialize(%d, %d, %d, %d, %d, %d)\n\r"), Mode, BPPMode, uiWidth, uiHeight, uiOffsetX, uiOffsetY));

	g_Win3Config.BitSwapping = BITSWP_DISABLE;
	g_Win3Config.ByteSwapping = BYTSWP_DISABLE;
	g_Win3Config.HalfWordSwapping = HAWSWP_DISABLE;

	switch(BPPMode)
	{
	//case DISP_1BPP:
	//case DISP_2BPP:
	//case DISP_4BPP:
	//case DISP_16BPP_A555:
	//case DISP_16BPP_I555:
	//case DISP_18BPP_A665:
	//case DISP_19BPP_A666:
	//case DISP_24BPP_A887:
	//case DISP_25BPP_A888:
	case DISP_16BPP_565:
		g_Win3Config.uiPageWidth = uiWidth*2;	// 2 byte per pixel
		g_Win3Config.HalfWordSwapping = HAWSWP_ENABLE;	// 16BPP need Halfword Swapping
		break;
	case DISP_18BPP_666:
	case DISP_24BPP_888:
		g_Win3Config.uiPageWidth = uiWidth*4;	// 4 byte per pixel
		break;
	default:
		DISP_ERR((_T("[DISP:ERR] Disp_window3_initialize() : Unsupported BPP Mode [%d]\n\r"), BPPMode));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
		break;
	}

	g_Win3Config.BPP_Mode = BPPMode;
	g_Win3Config.uiWidth = uiWidth;
	g_Win3Config.uiHeight = uiHeight;
	g_Win3Config.uiOffsetX = uiOffsetX;
	g_Win3Config.uiOffsetY = uiOffsetY;

	if (g_Win3Config.uiPageWidth%4)
	{
		DISP_ERR((_T("[DISP:ERR] Disp_window3_initialize() : uiPageWidth is not Word Aligned [%d]\n\r"), g_Win0Config.uiPageWidth));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
	}
	else if (g_Win3Config.uiPageWidth >= 16*4)
	{
		g_Win3Config.BurstLength = BURSTLEN_16WORD;
	}
	else if (g_Win3Config.uiPageWidth >= 8*4)
	{
		g_Win3Config.BurstLength = BURSTLEN_8WORD;
	}
	else
	{
		g_Win3Config.BurstLength = BURSTLEN_4WORD;
	}

	g_pDispConReg->WINCON3 = g_Win3Config.BitSwapping | g_Win3Config.ByteSwapping | g_Win3Config.HalfWordSwapping |
							g_Win3Config.BurstLength | BLEND_PER_PLANE | BPPMODE_F(g_Win3Config.BPP_Mode) |
							ALPHASEL_ALPHA0;

	g_pDispConReg->VIDOSD3A = OSD_LEFTTOPX_F(g_Win3Config.uiOffsetX) | OSD_LEFTTOPY_F(g_Win3Config.uiOffsetY);

	g_pDispConReg->VIDOSD3B = OSD_RIGHTBOTX_F(g_Win3Config.uiWidth+g_Win3Config.uiOffsetX-1) |
								OSD_RIGHTBOTY_F(g_Win3Config.uiHeight+g_Win3Config.uiOffsetY-1);

	g_pDispConReg->VIDOSD3C = 0x0;

	DISP_MSG((_T("[DISP]--Disp_window3_initialize() : %d\n\r"), error));

	return error;
}

static DISP_ERROR Disp_window4_initialize(DISP_WINDOW_MODE Mode, DISP_BPP_MODE BPPMode, unsigned int uiWidth, unsigned int uiHeight, unsigned int uiOffsetX, unsigned int uiOffsetY)
{
	DISP_ERROR error = DISP_SUCCESS;

	DISP_MSG((_T("[DISP]++Disp_window4_initialize(%d, %d, %d, %d, %d, %d)\n\r"), Mode, BPPMode, uiWidth, uiHeight, uiOffsetX, uiOffsetY));

	g_Win4Config.BitSwapping = BITSWP_DISABLE;
	g_Win4Config.ByteSwapping = BYTSWP_DISABLE;
	g_Win4Config.HalfWordSwapping = HAWSWP_DISABLE;

	switch(BPPMode)
	{
	//case DISP_1BPP:
	//case DISP_2BPP:
	//case DISP_16BPP_A555:
	//case DISP_16BPP_I555:
	//case DISP_18BPP_A665:
	//case DISP_19BPP_A666:
	//case DISP_24BPP_A887:
	//case DISP_25BPP_A888:
	case DISP_16BPP_565:
		g_Win4Config.uiPageWidth = uiWidth*2;	// 2 byte per pixel
		g_Win4Config.HalfWordSwapping = HAWSWP_ENABLE;	// 16BPP need Halfword Swapping
		break;
	case DISP_18BPP_666:
	case DISP_24BPP_888:
		g_Win4Config.uiPageWidth = uiWidth*4;	// 4 byte per pixel
		break;
	default:
		DISP_ERR((_T("[DISP:ERR] Disp_window4_initialize() : Unsupported BPP Mode [%d]\n\r"), BPPMode));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
		break;
	}

	g_Win4Config.BPP_Mode = BPPMode;
	g_Win4Config.uiWidth = uiWidth;
	g_Win4Config.uiHeight = uiHeight;
	g_Win4Config.uiOffsetX = uiOffsetX;
	g_Win4Config.uiOffsetY = uiOffsetY;

	if (g_Win4Config.uiPageWidth%4)
	{
		DISP_ERR((_T("[DISP:ERR] Disp_window4_initialize() : uiPageWidth is not Word Aligned [%d]\n\r"), g_Win0Config.uiPageWidth));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
	}
	else if (g_Win4Config.uiPageWidth >= 16*4)
	{
		g_Win4Config.BurstLength = BURSTLEN_16WORD;
	}
	else if (g_Win4Config.uiPageWidth >= 8*4)
	{
		g_Win4Config.BurstLength = BURSTLEN_8WORD;
	}
	else
	{
		g_Win4Config.BurstLength = BURSTLEN_4WORD;
	}

	g_pDispConReg->WINCON4 = g_Win4Config.BitSwapping | g_Win4Config.ByteSwapping | g_Win4Config.HalfWordSwapping |
							g_Win4Config.BurstLength | BLEND_PER_PLANE | BPPMODE_F(g_Win4Config.BPP_Mode) |
							ALPHASEL_ALPHA0;

	g_pDispConReg->VIDOSD4A = OSD_LEFTTOPX_F(g_Win4Config.uiOffsetX) | OSD_LEFTTOPY_F(g_Win4Config.uiOffsetY);

	g_pDispConReg->VIDOSD4B = OSD_RIGHTBOTX_F(g_Win4Config.uiWidth+g_Win4Config.uiOffsetX-1) |
								OSD_RIGHTBOTY_F(g_Win4Config.uiHeight+g_Win4Config.uiOffsetY-1);

	g_pDispConReg->VIDOSD4C = 0x0;

	DISP_MSG((_T("[DISP]--Disp_window4_initialize() : %d\n\r"), error));

	return error;
}

static BOOL Disp_get_vclk_direction_divider(unsigned int CLKSrc, unsigned int *ClkDir, unsigned int *ClkDiv)
{
	double dTmpDiv = 0, dVclkSrc = 0;
	DWORD HozTime = 0;
	DWORD VerTime = 0;

	DISP_MSG((_T("[DISP]++Disp_get_vclk_direction_divider(%d)\n\r"), CLKSrc));

	if (CLKSrc == CLKSEL_F_HCLK)
	{
		dVclkSrc = S3C6400_HCLK;
		DISP_INF((_T("[DISP:INF] VCLK Source = HCLK (%d Hz)\n\r"), (unsigned int)dVclkSrc));
	}
	else if (CLKSrc == CLKSEL_F_LCDCLK)
	{
		dVclkSrc = S3C6400_ECLK;
		DISP_INF((_T("[DISP:INF] VCLK Source = LCDCLK (%d Hz)\n\r"), (unsigned int)dVclkSrc));
	}
	else if (CLKSrc == CLKSEL_F_EXT27M)
	{
		dVclkSrc = 27000000;	// 27MHz
		DISP_INF((_T("[DISP:INF] VCLK Source = EXT27M (%d Hz)\n\r"), (unsigned int)dVclkSrc));
	}
	else
	{
		DISP_ERR((_T("[DISP:ERR] --Disp_get_vclk_direction_divider() : Unknown CLKSrc = %d\n\r"), CLKSrc));
		return FALSE;
	}

	switch(g_DevInfo.RGBOutMode)
	{
		case DISP_16BIT_RGB565_P:
		case DISP_18BIT_RGB666_P:
		case DISP_24BIT_RGB888_P:
			HozTime = g_DevInfo.uiWidth+g_DevInfo.HBPD_Value+g_DevInfo.HFPD_Value+g_DevInfo.HSPW_Value;
			break;
		case DISP_16BIT_RGB565_S:
		case DISP_18BIT_RGB666_S:
		case DISP_24BIT_RGB888_S:
			HozTime = g_DevInfo.uiWidth*3+g_DevInfo.HBPD_Value+g_DevInfo.HFPD_Value+g_DevInfo.HSPW_Value;
			break;
	}
	VerTime = g_DevInfo.uiHeight+g_DevInfo.VBPD_Value+g_DevInfo.VFPD_Value+g_DevInfo.VSPW_Value;

	dTmpDiv = dVclkSrc/(double)(HozTime*VerTime*g_DevInfo.Frame_Rate);

	dTmpDiv = (dTmpDiv+0.5)*10;
	*ClkDiv = (unsigned int)(dTmpDiv/10.0);

	if (*ClkDiv < 1)
	{
		DISP_ERR((_T("[DISP:ERR] --Disp_get_vclk_direction_divider() : VCLK Source is Too Slow\n\r")));
		return FALSE;
	}
	else	 if (*ClkDiv == 1)
	{
		// No Divide, Direct Clock
		*ClkDir = CLKDIR_DIRECT;
		DISP_INF((_T("[DISP:INF] VCLK Direction = Direct, VCLK = %d Hz\n\r"), *ClkDiv, (unsigned int)dVclkSrc/(*ClkDiv)));
	}
	else
	{
		// Divide by more than 1, Divided Clock
		*ClkDir = CLKDIR_DIVIDED;
		DISP_INF((_T("[DISP:INF] VCLK Divider = %d, Direction = Divided, VCLK = %d Hz\n\r"), *ClkDiv, (unsigned int)dVclkSrc/(*ClkDiv)));
	}

	DISP_MSG((_T("[DISP] --Disp_get_vclk_direction_divider()\n\r")));

	return TRUE;
}

static BOOL Disp_get_vclk_direction_divider_forTVEnc(unsigned int CLKSrc, unsigned int *ClkDir, unsigned int *ClkDiv)
{
	BOOL bRet;
	unsigned int uiVclkSrc;

	DISP_ERR((_T("[DISP]++Disp_get_vclk_direction_divider_forTVEnc(%d)\n\r"), CLKSrc));

	bRet = Disp_get_vclk_direction_divider(CLKSrc, ClkDir, ClkDiv);

	if (CLKSrc == CLKSEL_F_HCLK)
	{
		uiVclkSrc = S3C6400_HCLK;
	}
	else if (CLKSrc == CLKSEL_F_LCDCLK)
	{
		uiVclkSrc = S3C6400_ECLK;
	}
	else if (CLKSrc == CLKSEL_F_EXT27M)
	{
		uiVclkSrc = 27000000;	// 27MHz
	}
	else
	{
		DISP_ERR((_T("[DISP:ERR] --Disp_get_vclk_direction_divider_forTVEnc() : Unknown CLKSrc = %d\n\r"), CLKSrc));
		return FALSE;
	}

	if ((*ClkDir) == CLKDIR_DIVIDED)
	{
		if (uiVclkSrc/(*ClkDiv) < MINIMUM_VCLK_FOR_TV)
		{
			*ClkDiv = uiVclkSrc/MINIMUM_VCLK_FOR_TV;
			DISP_INF((_T("[DISP:INF] Disp_get_vclk_direction_divider_forTVEnc() : Force Divider for Minimum VCLK of TV Encoder -> %d (%d Hz)\n\r"), *ClkDiv, uiVclkSrc/(*ClkDiv)));
		}
	}

	DISP_ERR((_T("[DISP] --Disp_get_vclk_direction_divider_forTVEnc()\n\r")));

	return TRUE;

}