s3c6400_display_con.c

Samsung公司S3C6400芯片的BSP源码包

			{
				g_pDispConReg->WINCON1 |= (ENWIN_F_ENABLE | g_Win1Config.LocalPathEnable);
			}
			else
			{
				g_pDispConReg->WINCON1 &= ~(ENWIN_F_ENABLE | g_Win1Config.LocalPathEnable);
			}
			break;
		case DISP_WIN2:
			if (WinOnOff == DISP_WINDOW_ON)
			{
				g_pDispConReg->WINCON2 |= (ENWIN_F_ENABLE | g_Win2Config.LocalPathEnable);
			}
			else
			{
				g_pDispConReg->WINCON2 &= ~(ENWIN_F_ENABLE | g_Win2Config.LocalPathEnable);
			}
			break;
		case DISP_WIN3:
			if (WinOnOff == DISP_WINDOW_ON)
			{
				g_pDispConReg->WINCON3 |= ENWIN_F_ENABLE;
			}
			else
			{
				g_pDispConReg->WINCON3 &= ~ENWIN_F_ENABLE;
			}
			break;
		case DISP_WIN4:
			if (WinOnOff == DISP_WINDOW_ON)
			{
				g_pDispConReg->WINCON4 |= ENWIN_F_ENABLE;
			}
			else
			{
				g_pDispConReg->WINCON4 &= ~ENWIN_F_ENABLE;
			}
			break;
		default:
			DISP_ERR((_T("[DISP:ERR] Disp_window_onfoff() : Unknown Window Number [%d]\n\r"), Win));
			error = DISP_ERROR_ILLEGAL_PARAMETER;
			break;
		}
	}
	else
	{
		DISP_ERR((_T("[DISP:ERR] Disp_window_onfoff() : Unknown OnOff Parameter [%d]\n\r"), WinOnOff));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
	}

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

	return error;
}

DISP_WINDOW_ONOFF Disp_get_window_status(DISP_WINDOW Win)
{
	unsigned int uiWinConReg;

	switch(Win)
	{
	case DISP_WIN0:
		uiWinConReg = g_pDispConReg->WINCON0;
		break;
	case DISP_WIN1:
		uiWinConReg = g_pDispConReg->WINCON1;
		break;
	case DISP_WIN2:
		uiWinConReg = g_pDispConReg->WINCON2;
		break;
	case DISP_WIN3:
		uiWinConReg = g_pDispConReg->WINCON3;
		break;
	case DISP_WIN4:
		uiWinConReg = g_pDispConReg->WINCON4;
		break;
	default:
		DISP_ERR((_T("[DISP:ERR] Disp_get_window_status() : Unknown Window Number [%d]\n\r"), Win));
		break;
	}

	if (uiWinConReg & ENWIN_F_ENABLE)
	{
		return DISP_WINDOW_ON;
	}
	else
	{
		return DISP_WINDOW_OFF;
	}
}

DISP_ERROR Disp_set_dithering_mode(DISP_DITHER_MODE Mode)
{
	DISP_ERROR error = DISP_SUCCESS;

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

	switch(Mode)
	{
	case DISP_DITHER_OFF:
		g_pDispConReg->DITHMODE = DITHEN_F_DISABLE;
		break;
	case DISP_DITHER_565:
		g_pDispConReg->DITHMODE = RDITHPOS_5BIT | GDITHPOS_6BIT | BDITHPOS_5BIT | DITHEN_F_ENABLE;
		break;
	case DISP_DITHER_666:
		g_pDispConReg->DITHMODE = RDITHPOS_6BIT | GDITHPOS_6BIT | BDITHPOS_6BIT | DITHEN_F_ENABLE;
		break;
	case DISP_DITHER_888:
		g_pDispConReg->DITHMODE = RDITHPOS_8BIT | GDITHPOS_8BIT | BDITHPOS_8BIT | DITHEN_F_ENABLE;
		break;
	default:
		DISP_ERR((_T("[DISP:ERR] Disp_set_dithering_mode() : Unknown Mode [%d]\n\r"), Mode));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
		g_pDispConReg->DITHMODE = DITHEN_F_DISABLE;
		break;
	}

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

	return error;
}

DISP_ERROR Disp_set_window_color_map(DISP_WINDOW Win, BOOL bOnOff, unsigned int uiColorValue)
{
	DISP_ERROR error = DISP_SUCCESS;

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

	switch(Win)
	{
	case DISP_WIN0:
		if (bOnOff)
		{
			g_pDispConReg->WIN0MAP = MAPCOLEN_F_ENABLE | MAPCOLOR(uiColorValue);
		}
		else
		{
			g_pDispConReg->WIN0MAP = MAPCOLEN_F_DISABLE;
		}
		break;
	case DISP_WIN1:
		if (bOnOff)
		{
			g_pDispConReg->WIN1MAP = MAPCOLEN_F_ENABLE | MAPCOLOR(uiColorValue);
		}
		else
		{
			g_pDispConReg->WIN1MAP = MAPCOLEN_F_DISABLE;
		}
		break;
	case DISP_WIN2:
		if (bOnOff)
		{
			g_pDispConReg->WIN2MAP = MAPCOLEN_F_ENABLE | MAPCOLOR(uiColorValue);
		}
		else
		{
			g_pDispConReg->WIN2MAP = MAPCOLEN_F_DISABLE;
		}
		break;
	case DISP_WIN3:
		if (bOnOff)
		{
			g_pDispConReg->WIN3MAP = MAPCOLEN_F_ENABLE | MAPCOLOR(uiColorValue);
		}
		else
		{
			g_pDispConReg->WIN3MAP = MAPCOLEN_F_DISABLE;
		}
		break;
	case DISP_WIN4:
		if (bOnOff)
		{
			g_pDispConReg->WIN4MAP = MAPCOLEN_F_ENABLE | MAPCOLOR(uiColorValue);
		}
		else
		{
			g_pDispConReg->WIN4MAP = MAPCOLEN_F_DISABLE;
		}
		break;
	default:
		DISP_ERR((_T("[DISP:ERR] Disp_set_window_color_map() : Unknown Window Number [%d]\n\r"), Win));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
		break;
	}

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

	return error;
}

DISP_ERROR Disp_set_color_key(DISP_WINDOW Win, BOOL bOnOff, DISP_COLOR_KEY_DIRECTION Direction, unsigned int uiColorKey, unsigned int uiComparekey)
{
	DISP_ERROR error = DISP_SUCCESS;

	unsigned int uiKeyDir;

	DISP_MSG((_T("[DISP]++Disp_set_color_key(%d, %d, %d, 0x%08x, 0x%08x)\n\r"), Win, bOnOff, Direction, uiColorKey, uiComparekey));

	if (Direction == DISP_FG_MATCH_BG_DISPLAY)
	{
		uiKeyDir = DIRCON_FG_MATCH_BG_DISPLAY;
	}
	else
	{
		uiKeyDir = DIRCON_BG_MATCH_FG_DISPLAY;
	}

	switch(Win)
	{
	case DISP_WIN1:
		if (bOnOff)
		{
			g_pDispConReg->W1KEYCON0 = KEYBLEN_DISABLE | KEYEN_F_ENABLE | uiKeyDir | COMPKEY(uiComparekey);
			g_pDispConReg->W1KEYCON1 = COLVAL(uiColorKey);
		}
		else
		{
			g_pDispConReg->W1KEYCON0 = KEYBLEN_DISABLE | KEYEN_F_DISABLE;
		}
		break;
	case DISP_WIN2:
		if (bOnOff)
		{
			g_pDispConReg->W2KEYCON0 = KEYBLEN_DISABLE | KEYEN_F_ENABLE | uiKeyDir | COMPKEY(uiComparekey);
			g_pDispConReg->W2KEYCON1 = COLVAL(uiColorKey);
		}
		else
		{
			g_pDispConReg->W2KEYCON0 = KEYBLEN_DISABLE | KEYEN_F_DISABLE;
		}
		break;
	case DISP_WIN3:
		if (bOnOff)
		{
			g_pDispConReg->W3KEYCON0 = KEYBLEN_DISABLE | KEYEN_F_ENABLE | uiKeyDir | COMPKEY(uiComparekey);
			g_pDispConReg->W3KEYCON1 = COLVAL(uiColorKey);
		}
		else
		{
			g_pDispConReg->W3KEYCON0 = KEYBLEN_DISABLE | KEYEN_F_DISABLE;
		}
		break;
	case DISP_WIN4:
		if (bOnOff)
		{
			g_pDispConReg->W4KEYCON0 = KEYBLEN_DISABLE | KEYEN_F_ENABLE | uiKeyDir | COMPKEY(uiComparekey);
			g_pDispConReg->W4KEYCON1 = COLVAL(uiColorKey);
		}
		else
		{
			g_pDispConReg->W4KEYCON0 = KEYBLEN_DISABLE | KEYEN_F_DISABLE;
		}
		break;
	default:
		DISP_ERR((_T("[DISP:ERR] Disp_set_color_key() : Unknown Window Number [%d]\n\r"), Win));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
		break;
	}

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

	return error;
}

DISP_ERROR Disp_set_alpha_blending(DISP_WINDOW Win, DISP_ALPHA_BLEND_METHOD Method, unsigned int uiAlphaSet0, unsigned int uiAlphaSet1)
{
	DISP_ERROR error = DISP_SUCCESS;
	unsigned int uiMethod;

	DISP_MSG((_T("[DISP]++Disp_set_alpha_blending(%d, %d, 0x%08x, 0x%08x)\n\r"), Win, Method, uiAlphaSet0, uiAlphaSet1));

	if (Method == DISP_ALPHA_PER_PLANE)
	{
		uiMethod = BLEND_PER_PLANE;
	}
	else
	{
		uiMethod = BLEND_PER_PIXEL;
	}

	switch(Win)
	{
	case DISP_WIN1:
		g_pDispConReg->WINCON1 =  (g_pDispConReg->WINCON1 & ~(BLEND_PER_PIXEL|ALPHASEL_ALPHA1)) | uiMethod;
		g_pDispConReg->VIDOSD1C = ALPHA0_R(uiAlphaSet0) | ALPHA0_G(uiAlphaSet0) | ALPHA0_B(uiAlphaSet0)
									| ALPHA1_R(uiAlphaSet1) | ALPHA1_G(uiAlphaSet1) | ALPHA1_B(uiAlphaSet1);
		break;
	case DISP_WIN2:
		g_pDispConReg->WINCON2 =  (g_pDispConReg->WINCON2 & ~(BLEND_PER_PIXEL|ALPHASEL_ALPHA1)) | uiMethod;
		g_pDispConReg->VIDOSD2C = ALPHA0_R(uiAlphaSet0) | ALPHA0_G(uiAlphaSet0) | ALPHA0_B(uiAlphaSet0)
									| ALPHA1_R(uiAlphaSet1) | ALPHA1_G(uiAlphaSet1) | ALPHA1_B(uiAlphaSet1);
		break;
	case DISP_WIN3:
		g_pDispConReg->WINCON3 =  (g_pDispConReg->WINCON3 & ~(BLEND_PER_PIXEL|ALPHASEL_ALPHA1)) | uiMethod;
		g_pDispConReg->VIDOSD3C = ALPHA0_R(uiAlphaSet0) | ALPHA0_G(uiAlphaSet0) | ALPHA0_B(uiAlphaSet0)
									| ALPHA1_R(uiAlphaSet1) | ALPHA1_G(uiAlphaSet1) | ALPHA1_B(uiAlphaSet1);
		break;
	case DISP_WIN4:
		g_pDispConReg->WINCON4 =  (g_pDispConReg->WINCON4 & ~(BLEND_PER_PIXEL|ALPHASEL_ALPHA1)) | uiMethod;
		g_pDispConReg->VIDOSD4C = ALPHA0_R(uiAlphaSet0) | ALPHA0_G(uiAlphaSet0) | ALPHA0_B(uiAlphaSet0)
									| ALPHA1_R(uiAlphaSet1) | ALPHA1_G(uiAlphaSet1) | ALPHA1_B(uiAlphaSet1);
		break;
	default:
		DISP_ERR((_T("[DISP:ERR] Disp_set_alpha_blending() : Unknown Window Number [%d]\n\r"), Win));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
		break;
	}

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

	return error;
}

DISP_ERROR Disp_set_frame_interrupt(DISP_FRAME_INTERRUPT FrameInt)
{
	DISP_ERROR error = DISP_SUCCESS;

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

	g_pDispConReg->VIDINTCON0 &= ~FRAMEINT_MASK;	// Clear Al Frame Interrupt Bit

	switch(FrameInt)
	{
	case DISP_FRMINT_BACKPORCH:
		g_pDispConReg->VIDINTCON0 |= FRAMESEL0_BACK;
		break;
	case DISP_FRMINT_VSYNC:
		g_pDispConReg->VIDINTCON0 |= FRAMESEL0_VSYNC;
		break;
	case DISP_FRMINT_ACTIVE:
		g_pDispConReg->VIDINTCON0 |= FRAMESEL0_ACTIVE;
		break;
	case DISP_FRMINT_FRONTPORCH:
		g_pDispConReg->VIDINTCON0 |= FRAMESEL0_FRONT;
		break;
	default:
		DISP_ERR((_T("[DISP:ERR] Disp_set_frame_interrupt() : Unknown Frame Interrupt [%d]\n\r"), FrameInt));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
		break;
	}

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

	return error;
}

DISP_ERROR Disp_enable_frame_interrupt(void)
{
	DISP_ERROR error = DISP_SUCCESS;

	DISP_MSG((_T("[DISP]++Disp_enable_frame_interrupt()\n\r")));

	g_pDispConReg->VIDINTCON0 |= (INTFRMEN_ENABLE | INTEN_ENABLE);

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

	return error;
}

DISP_ERROR Disp_disable_frame_interrupt(void)
{
	DISP_ERROR error = DISP_SUCCESS;

	DISP_MSG((_T("[DISP]++Disp_disable_frame_interrupt()\n\r")));

	if (g_pDispConReg->VIDINTCON0 & INTFIFOEN_ENABLE)
	{
		// If FIFO Interrupt is enabled, Clear only Frame Interrupt Enable Bit
		g_pDispConReg->VIDINTCON0 &= ~INTFRMEN_ENABLE;
	}
	else
	{
		g_pDispConReg->VIDINTCON0 &= ~(INTFRMEN_ENABLE | INTEN_ENABLE);
	}

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

	return error;
}

DISP_ERROR Disp_set_fifo_interrupt(DISP_WINDOW Win, DISP_FIFO_INTERRUPT_LEVEL Level)
{
	DISP_ERROR error = DISP_SUCCESS;

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

	g_pDispConReg->VIDINTCON0 &= ~FIFOINT_MASK;	// Clear Al FIFO Interrupt Bit

	switch(Win)
	{
	case DISP_WIN0:
		g_pDispConReg->VIDINTCON0 |= FIFOSEL_WIN0;
		break;
	case DISP_WIN1:
		g_pDispConReg->VIDINTCON0 |= FIFOSEL_WIN1;
		break;
	case DISP_WIN2:
		g_pDispConReg->VIDINTCON0 |= FIFOSEL_WIN2;
		break;
	case DISP_WIN3:
		g_pDispConReg->VIDINTCON0 |= FIFOSEL_WIN3;
		break;
	case DISP_WIN4:
		g_pDispConReg->VIDINTCON0 |= FIFOSEL_WIN4;
		break;
	default:
		DISP_ERR((_T("[DISP:ERR] Disp_set_fifo_interrupt() : Unknown Window Number [%d]\n\r"), Win));
		error = DISP_ERROR_ILLEGAL_PARAMETER;
		break;
	}

	switch(Level)
	{
	case DISP_FIFO_0_25:
		g_pDispConReg->VIDINTCON0 |= FIFOLEVEL_25;
		break;
	case DISP_FIFO_0_50:
		g_pDispConReg->VIDINTCON0 |= FIFOLEVEL_50;
		break;
	case DISP_FIFO_0_75:
		g_pDispConReg->VIDINTCON0 |= FIFOLEVEL_75;
		break;
	case DISP_FIFO_EMPTY:
		g_pDispConReg->VIDINTCON0 |= FIFOLEVEL_EMPTY;
		break;
	case DISP_FIFO_FULL:
		g_pDispConReg->VIDINTCON0 |= FIFOLEVEL_FULL;