s3c6400_display_con.c

Samsung公司S3C6400芯片的BSP源码包

#include <windows.h>
#include <bsp_cfg.h>	// for reference S3C6400_HCLK, S3C6400_ECLK
#include <s3c6400.h>
#include "s3c6400_display_con.h"
#include "s3c6400_display_con_macro.h"

#ifdef	REMOVE_BEFORE_RELEASE
#define DISP_MSG(x)
#define DISP_INF(x)
#define DISP_ERR(x)	RETAILMSG(TRUE, x)
#else
//#define DISP_MSG(x)	RETAILMSG(TRUE, x)
#define DISP_MSG(x)
#define DISP_INF(x)	RETAILMSG(TRUE, x)
//#define DISP_INF(x)
#define DISP_ERR(x)	RETAILMSG(TRUE, x)
//#define DISP_ERR(x)
#endif

static volatile S3C6400_DISPLAY_REG *g_pDispConReg = NULL;
static volatile S3C6400_MSMIF_REG *g_pMSMIFReg = NULL;
static volatile S3C6400_GPIO_REG *g_pGPIOReg = NULL;

static tDevInfo g_DevInfo;
static tDispWindow0Config g_Win0Config;
static tDispWindow12Config g_Win1Config;
static tDispWindow12Config g_Win2Config;
static tDispWindow34Config g_Win3Config;
static tDispWindow34Config g_Win4Config;

DISP_ERROR Disp_initialize_register_address(void *pDispConReg, void *pMSMIFReg, void *pGPIOReg)
{
	DISP_ERROR error = DISP_SUCCESS;

	DISP_MSG((_T("[DISP]++Disp_initialize_register_address(0x%08x, 0x%08x, 0x%08x)\n\r"), pDispConReg, pMSMIFReg, pGPIOReg));

	if (pDispConReg == NULL || pMSMIFReg == NULL || pGPIOReg == NULL)
	{
		DISP_ERR((_T("[DISP:ERR] Disp_initialize_register_address() : NULL pointer parameter\n\r")));
		error = DISP_ERROR_NULL_PARAMETER;
	}
	else
	{
		g_pDispConReg = (S3C6400_DISPLAY_REG *)pDispConReg;
		g_pMSMIFReg = (S3C6400_MSMIF_REG *)pMSMIFReg;
		g_pGPIOReg = (S3C6400_GPIO_REG *)pGPIOReg;
		DISP_INF((_T("[DISP:INF] g_pDispConReg = 0x%08x\n\r"), g_pDispConReg));
		DISP_INF((_T("[DISP:INF] g_pMSMIFReg = 0x%08x\n\r"), g_pMSMIFReg));
		DISP_INF((_T("[DISP:INF] g_pGPIOReg    = 0x%08x\n\r"), g_pGPIOReg));
	}

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

	return error;
}

DISP_ERROR Disp_set_output_device_information(DISP_OUT_DEV_TYPE DevType)
{
	DISP_ERROR error = DISP_SUCCESS;

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

	if (DevType == DISP_DEV_LTS222QV_RGB)
	{
		DISP_INF((_T("[DISP:INF] Output Devce Type [%d] = DISP_DEV_LTS222QV_RGBAAA\n\r"), DevType));
		g_DevInfo.RGBOutMode = DISP_18BIT_RGB666_S;
		g_DevInfo.uiWidth = 240;
		g_DevInfo.uiHeight = 320;
		g_DevInfo.VBPD_Value = 7;
		g_DevInfo.VFPD_Value = 10;
		g_DevInfo.VSPW_Value = 3;
		g_DevInfo.HBPD_Value = 2;
		g_DevInfo.HFPD_Value = 2;
		g_DevInfo.HSPW_Value = 1;
		g_DevInfo.VCLK_Polarity = IVCLK_FALL_EDGE;
		g_DevInfo.HSYNC_Polarity = IHSYNC_LOW_ACTIVE;
		g_DevInfo.VSYNC_Polarity = IVSYNC_LOW_ACTIVE;
		g_DevInfo.VDEN_Polarity = IVDEN_HIGH_ACTIVE;
		g_DevInfo.PNR_Mode = PNRMODE_RGB_S;
		g_DevInfo.VCLK_Source = CLKSEL_F_LCDCLK;
		g_DevInfo.VCLK_Direction = CLKDIR_DIVIDED;
		g_DevInfo.Frame_Rate = 60;
	}
	else if (DevType == DISP_DEV_LTV350QV_RGB)
	{
		DISP_INF((_T("[DISP:INF] Output Devce Type [%d] = DISP_DEV_LTV350QV_RGB\n\r"), DevType));
		g_DevInfo.RGBOutMode = DISP_16BIT_RGB565_P;
		g_DevInfo.uiWidth = 320;
		g_DevInfo.uiHeight = 240;
		g_DevInfo.VBPD_Value = 5;
		g_DevInfo.VFPD_Value = 3;
		g_DevInfo.VSPW_Value = 4;
		g_DevInfo.HBPD_Value = 5;
		g_DevInfo.HFPD_Value = 3;
		g_DevInfo.HSPW_Value = 10;
		g_DevInfo.VCLK_Polarity = IVCLK_RISE_EDGE;
		g_DevInfo.HSYNC_Polarity = IHSYNC_LOW_ACTIVE;
		g_DevInfo.VSYNC_Polarity = IVSYNC_LOW_ACTIVE;
		g_DevInfo.VDEN_Polarity = IVDEN_LOW_ACTIVE;
		g_DevInfo.PNR_Mode = PNRMODE_RGB_P;
		g_DevInfo.VCLK_Source = CLKSEL_F_LCDCLK;
		g_DevInfo.VCLK_Direction = CLKDIR_DIVIDED;
		g_DevInfo.Frame_Rate = 60;	// VCLK (Max 10 MHz)
	}
	else if (DevType == DISP_DEV_LTE480WV_RGB)
	{
		DISP_INF((_T("[DISP:INF] Output Devce Type [%d] = DISP_DEV_LTE480WV_RGB\n\r"), DevType));
		g_DevInfo.RGBOutMode = DISP_16BIT_RGB565_P;
		g_DevInfo.uiWidth = 800;
		g_DevInfo.uiHeight = 480;
		g_DevInfo.VBPD_Value = 3;
		g_DevInfo.VFPD_Value = 5;
		g_DevInfo.VSPW_Value = 5;
		g_DevInfo.HBPD_Value = 13;
		g_DevInfo.HFPD_Value = 8;
		g_DevInfo.HSPW_Value = 3;
		g_DevInfo.VCLK_Polarity = IVCLK_FALL_EDGE;
		g_DevInfo.HSYNC_Polarity = IHSYNC_LOW_ACTIVE;
		g_DevInfo.VSYNC_Polarity = IVSYNC_LOW_ACTIVE;
		g_DevInfo.VDEN_Polarity = IVDEN_HIGH_ACTIVE;
		g_DevInfo.PNR_Mode = PNRMODE_RGB_P;
		g_DevInfo.VCLK_Source = CLKSEL_F_LCDCLK;
		g_DevInfo.VCLK_Direction = CLKDIR_DIVIDED;
		g_DevInfo.Frame_Rate = 60;	// VCLK > 24.5 MHz (Max 35.7 MHz)
	}
	else if (DevType == DISP_DEV_LTP700WV_RGB)
	{
		DISP_INF((_T("[DISP:INF] Output Devce Type [%d] = DISP_DEV_LTP700WV_RGB\n\r"), DevType));
		g_DevInfo.RGBOutMode = DISP_24BIT_RGB888_P;
		g_DevInfo.uiWidth = 800;
		g_DevInfo.uiHeight = 480;
		g_DevInfo.VBPD_Value = 7;
		g_DevInfo.VFPD_Value = 5;
		g_DevInfo.VSPW_Value = 1;
		g_DevInfo.HBPD_Value = 13;
		g_DevInfo.HFPD_Value = 8;
		g_DevInfo.HSPW_Value = 3;
		g_DevInfo.VCLK_Polarity = IVCLK_FALL_EDGE;
		g_DevInfo.HSYNC_Polarity = IHSYNC_LOW_ACTIVE;
		g_DevInfo.VSYNC_Polarity = IVSYNC_LOW_ACTIVE;
		g_DevInfo.VDEN_Polarity = IVDEN_HIGH_ACTIVE;
		g_DevInfo.PNR_Mode = PNRMODE_RGB_P;
		g_DevInfo.VCLK_Source = CLKSEL_F_LCDCLK;
		g_DevInfo.VCLK_Direction = CLKDIR_DIVIDED;
		g_DevInfo.Frame_Rate = 60;
	}
	else
	{
		DISP_ERR((_T("[DISP:ERR] Disp_set_output_device_information() : Unknown device type [%d]\n\r"), DevType));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
	}

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

	return error;
}

DISP_ERROR Disp_initialize_output_interface(DISP_VIDOUT_MODE VidoutMode)
{
	DISP_ERROR error = DISP_SUCCESS;

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

	if (g_pDispConReg == NULL || g_pGPIOReg == NULL)
	{
		DISP_ERR((_T("[DISP:ERR] Disp_initialize_output_interface() : Register Address Not Initialized\n\r")));
		error = DISP_ERROR_NOT_INITIALIZED;
	}

	g_DevInfo.VideoOutMode = VidoutMode;

	switch(VidoutMode)
	{
	case DISP_VIDOUT_RGBIF:
		Disp_initialize_port_RGBIF(g_DevInfo.RGBOutMode);
		Disp_initialize_RGBIF();
		break;
	case DISP_VIDOUT_TVENCODER:
		// TODO: Port Close ???? Disp_initialize_port_RGBIF(g_DevInfo.RGBOutMode);
		Disp_initialize_TVEnc();
		break;
	case DISP_VIDOUT_RGBIF_TVENCODER:
		Disp_initialize_port_RGBIF(g_DevInfo.RGBOutMode);
		Disp_initialize_RGBIF_withTVEnc();
		break;
	case DISP_VIDOUT_I80IF_LDI0:
	case DISP_VIDOUT_I80IF_LDI1:
	case DISP_VIDOUT_I80IF_LDI0_TVENCODER:
	case DISP_VIDOUT_I80IF_LDI1_TVENCODER:
	default:
		DISP_ERR((_T("[DISP:ERR] Disp_initialize_output_interface() : Not Implemented Video Output Mode [%d]\n\r"), VidoutMode));
		error = DISP_ERROR_NOT_IMPLEMENTED;
		break;
	}

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

	return error;
}

DISP_ERROR Disp_set_window_mode(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_set_window_mode(%d)\n\r"), Mode));

	switch(Mode)
	{
	case DISP_WIN0_DMA:
	case DISP_WIN0_POST_RGB:
	case DISP_WIN0_POST_YUV:
		Disp_window0_initialize(Mode, BPPMode, uiWidth, uiHeight, uiOffsetX, uiOffsetY);
		break;
	case DISP_WIN1_DMA:
	case DISP_WIN1_TVSCALER_RGB:
	case DISP_WIN1_TVSCALER_YUV:
	case DISP_WIN1_CIPREVIEW_RGB:
	case DISP_WIN1_CIPREVIEW_YUV:
		Disp_window1_initialize(Mode, BPPMode, uiWidth, uiHeight, uiOffsetX, uiOffsetY);
		break;
	case DISP_WIN2_DMA:
	case DISP_WIN2_TVSCALER_RGB:
	case DISP_WIN2_TVSCALER_YUV:
	case DISP_WIN2_CICODEC_RGB:
	case DISP_WIN2_CICODEC_YUV:
		Disp_window2_initialize(Mode, BPPMode, uiWidth, uiHeight, uiOffsetX, uiOffsetY);
		break;
	case DISP_WIN3_DMA:
		Disp_window3_initialize(Mode, BPPMode, uiWidth, uiHeight, uiOffsetX, uiOffsetY);
		break;
	case DISP_WIN4_DMA:
		Disp_window4_initialize(Mode, BPPMode, uiWidth, uiHeight, uiOffsetX, uiOffsetY);
		break;
	default:
		DISP_ERR((_T("[DISP:ERR] Disp_set_window_mode() : Unsupported Window Mode [%d]\n\r"), Mode));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
		break;
	}

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

	return error;
}

DISP_ERROR Disp_set_window_position(DISP_WINDOW Win, unsigned int uiOffsetX, unsigned int uiOffsetY)
{
	DISP_ERROR error = DISP_SUCCESS;

	DISP_MSG((_T("[DISP]++Disp_set_window_position(%d, %d, %d)\n\r"), Win, uiOffsetX, uiOffsetY));

	switch(Win)
	{
	case DISP_WIN0:
		g_Win0Config.uiOffsetX = uiOffsetX;
		g_Win0Config.uiOffsetY = uiOffsetY;

		g_pDispConReg->VIDOSD0A = OSD_LEFTTOPX_F(g_Win0Config.uiOffsetX) | OSD_LEFTTOPY_F(g_Win0Config.uiOffsetY);

		g_pDispConReg->VIDOSD0B = OSD_RIGHTBOTX_F(g_Win0Config.uiWidth+g_Win0Config.uiOffsetX-1) |
									OSD_RIGHTBOTY_F(g_Win0Config.uiHeight+g_Win0Config.uiOffsetY-1);
		break;
	case DISP_WIN1:
		g_Win1Config.uiOffsetX = uiOffsetX;
		g_Win1Config.uiOffsetY = uiOffsetY;

		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);
		break;
	case DISP_WIN2:
		g_Win2Config.uiOffsetX = uiOffsetX;
		g_Win2Config.uiOffsetY = uiOffsetY;

		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);
		break;
	case DISP_WIN3:
		g_Win3Config.uiOffsetX = uiOffsetX;
		g_Win3Config.uiOffsetY = uiOffsetY;

		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);
		break;
	case DISP_WIN4:
		g_Win4Config.uiOffsetX = uiOffsetX;
		g_Win4Config.uiOffsetY = uiOffsetY;

		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);
		break;
	default:
		DISP_ERR((_T("[DISP:ERR] Disp_set_window_position() : Unknown Window Number [%d]\n\r"), Win));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
		break;
	}

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

	return error;
}

DISP_ERROR Disp_set_framebuffer(DISP_WINDOW Win, unsigned int uiFrameBufferAddress)
{
	DISP_ERROR error = DISP_SUCCESS;

	DISP_MSG((_T("[DISP]++Disp_set_framebuffer(%d, 0x%08x)\n\r"), Win, uiFrameBufferAddress));

	switch(Win)
	{
	case DISP_WIN0:
		if (g_Win0Config.LocalPathEnable == LOCAL_PATH_ENABLE)
		{
			DISP_ERR((_T("[DISP:ERR] Disp_set_framebuffer() : Window0 Local Path is Enabled\n\r")));
			error = DISP_ERROR_ILLEGAL_PARAMETER;
		}
		else
		{
			g_pDispConReg->VIDW00ADD0B0 = VBANK_F(uiFrameBufferAddress>>24) | VBASEU_F(uiFrameBufferAddress);
			g_pDispConReg->VIDW00ADD1B0 = VBASEL_F(VBASEU_F(uiFrameBufferAddress)+g_Win0Config.uiPageWidth*g_Win0Config.uiHeight);
			g_pDispConReg->VIDW00ADD2 = PAGEWIDTH_F(g_Win0Config.uiPageWidth);
			g_pDispConReg->WINCON0 &= ~(BUFSEL_BUF1);	// Buffer set to Buf0
		}
		break;
	case DISP_WIN1:
		if (g_Win1Config.LocalPathEnable == LOCAL_PATH_ENABLE)
		{
			DISP_ERR((_T("[DISP:ERR] Disp_set_framebuffer() : Window1 Local Path is Enabled\n\r")));
			error = DISP_ERROR_ILLEGAL_PARAMETER;
		}
		else
		{
			g_pDispConReg->VIDW01ADD0B0 = VBANK_F(uiFrameBufferAddress>>24) | VBASEU_F(uiFrameBufferAddress);
			g_pDispConReg->VIDW01ADD1B0 = VBASEL_F(VBASEU_F(uiFrameBufferAddress)+g_Win1Config.uiPageWidth*g_Win1Config.uiHeight);
			g_pDispConReg->VIDW01ADD2 = PAGEWIDTH_F(g_Win1Config.uiPageWidth);
			g_pDispConReg->WINCON1 &= ~(BUFSEL_BUF1);	// Buffer set to Buf0
		}
		break;
	case DISP_WIN2:
		if (g_Win2Config.LocalPathEnable == LOCAL_PATH_ENABLE)
		{
			DISP_ERR((_T("[DISP:ERR] Disp_set_framebuffer() : Window2 Local Path is Enabled\n\r")));
			error = DISP_ERROR_ILLEGAL_PARAMETER;
		}
		else
		{
			g_pDispConReg->VIDW02ADD0 = VBANK_F(uiFrameBufferAddress>>24) | VBASEU_F(uiFrameBufferAddress);
			g_pDispConReg->VIDW02ADD1 = VBASEL_F(VBASEU_F(uiFrameBufferAddress)+g_Win2Config.uiPageWidth*g_Win2Config.uiHeight);
			g_pDispConReg->VIDW02ADD2 = PAGEWIDTH_F(g_Win2Config.uiPageWidth);
		}
		break;
	case DISP_WIN3:
		g_pDispConReg->VIDW03ADD0 = VBANK_F(uiFrameBufferAddress>>24) | VBASEU_F(uiFrameBufferAddress);
		g_pDispConReg->VIDW03ADD1 = VBASEL_F(VBASEU_F(uiFrameBufferAddress)+g_Win3Config.uiPageWidth*g_Win3Config.uiHeight);
		g_pDispConReg->VIDW03ADD2 = PAGEWIDTH_F(g_Win3Config.uiPageWidth);
		break;
	case DISP_WIN4:
		g_pDispConReg->VIDW04ADD0 = VBANK_F(uiFrameBufferAddress>>24) | VBASEU_F(uiFrameBufferAddress);
		g_pDispConReg->VIDW04ADD1 = VBASEL_F(VBASEU_F(uiFrameBufferAddress)+g_Win4Config.uiPageWidth*g_Win4Config.uiHeight);
		g_pDispConReg->VIDW04ADD2 = PAGEWIDTH_F(g_Win4Config.uiPageWidth);
		break;
	default:
		DISP_ERR((_T("[DISP:ERR] Disp_set_framebuffer() : Unknown Window Number [%d]\n\r"), Win));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
		break;
	}

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

	return error;
}

DISP_ERROR Disp_envid_onoff(DISP_ENVID_ONOFF EnvidOnOff)
{
	DISP_ERROR error = DISP_SUCCESS;

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

	if (EnvidOnOff == DISP_ENVID_ON)
	{
		g_pDispConReg->VIDCON0 |= (ENVID_ENABLE | ENVID_F_ENABLE);
	}
	else if (EnvidOnOff == DISP_ENVID_OFF)
	{
		g_pDispConReg->VIDCON0 &= ~(ENVID_F_ENABLE);	// Per Frame Off
	}
	else if (EnvidOnOff == DISP_ENVID_DIRECT_OFF)
	{
		g_pDispConReg->VIDCON0 &= ~(ENVID_ENABLE | ENVID_F_ENABLE);	// Direct Off
	}
	else
	{
		DISP_ERR((_T("[DISP:ERR] Disp_envid_onoff() : Unknown Parameter [%d]\n\r"), EnvidOnOff));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
	}

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

	return error;
}

DISP_ERROR Disp_window_onfoff(DISP_WINDOW Win, DISP_WINDOW_ONOFF WinOnOff)
{
	DISP_ERROR error = DISP_SUCCESS;

	DISP_MSG((_T("[DISP]++Disp_window_onfoff(%d, %d)\n\r"), Win, WinOnOff));

	if (WinOnOff == DISP_WINDOW_ON || WinOnOff == DISP_WINDOW_OFF)
	{
		switch(Win)
		{
		case DISP_WIN0:
			if (WinOnOff == DISP_WINDOW_ON)
			{
				g_pDispConReg->WINCON0 |= (ENWIN_F_ENABLE | g_Win0Config.LocalPathEnable);
			}
			else
			{
				g_pDispConReg->WINCON0 &= ~(ENWIN_F_ENABLE | g_Win0Config.LocalPathEnable);
			}
			break;
		case DISP_WIN1:
			if (WinOnOff == DISP_WINDOW_ON)