lcd_test.c

三星 s3c6400测试代码

		if (nSel>0 && nSel<(sizeof(lcd_cpuif_function)/8-1))
			 (lcd_cpuif_function[nSel].func)();
	}	
	
} 


static void SetWinOfFgAndBg(void)
{
	u32 uBgWinSel, uFgWinSel;
	bool bIsBgExit = false;
	bool bIsFgExit = false;

	while (true)
	{
		while(true)
		{
			Disp("[0] Exit\n");
			Disp("[1] WINDOW 0\n");
			Disp("[2] WINDOW 1\n");	
			Disp("[3] WINDOW 2\n");
			Disp("[4] WINDOW 3\n");	
			Disp("[5] WINDOW 4\n");

			Disp("\n");
			Disp(">>Select Window Number Used For BACKGROUND: ");
			uBgWinSel = GetIntNum();

			if (uBgWinSel == 0)
				return;
			else if (uBgWinSel >= 1 && uBgWinSel <= 5)
			{
				eBgWin =
					(uBgWinSel == 1) ? WIN0 :
					(uBgWinSel == 2) ? WIN1 :
					(uBgWinSel == 3) ? WIN2 :
					(uBgWinSel == 4) ? WIN3 : WIN4;

				bIsBgExit = true;
				break;
			}
			else
				Disp("Invalid Input! Retry It!!\n");
		}

		Disp("\n");
		
		while(true)
		{
			Disp("[0] Exit\n");
			Disp("[1] WINDOW 1\n");	
			Disp("[2] WINDOW 2\n");
			Disp("[3] WINDOW 3\n");	
			Disp("[4] WINDOW 4\n");

			Disp("\n");
			Disp(">>Select Window Number Used For FOREGROUND: ");
			uFgWinSel = GetIntNum();

			if (uFgWinSel == 0)
				return;
			else if (uFgWinSel >= 1 && uFgWinSel <= 4)
			{
				eFgWin =
					(uFgWinSel == 1) ? WIN1 :
					(uFgWinSel == 2) ? WIN2 :
					(uFgWinSel == 3) ? WIN3 : WIN4;

				bIsFgExit = true;
				break;
			}
			else
				Disp("Invalid Input! Retry It!!\n");
		}

		if ( (bIsBgExit == true || bIsFgExit == true) && ((int)eBgWin < (int)eFgWin) )
			break;

		if ((int)eBgWin >= (int)eFgWin)
		{
			Disp("Win. Num. Correspond To Foreground Must Be Larger Than That Of Background!\n");
			Disp("\n");
		}
	}
}

static void SetRgbBpp(void)
{
	u32 uSelBpp;

	while (true)
	{
		Disp("[0] Exit\n");
		Disp("[1] RGB16 bpp (R:5 G:6 B:5)\n");
		Disp("[2] RGB24 bpp (R:8 G:8 B:8)\n");

		Disp("\n");
		Disp("> Select Background's Bpp: ");
		uSelBpp = GetIntNum();

		if (uSelBpp == 0)
			return;
		else if (uSelBpp >= 1 && uSelBpp <= 2)
		{
			eBgBpp =  (uSelBpp == 1) ? RGB16 : RGB24;

			break;
		}
		else
			Disp("Invalid Input! Retry It!!\n");
	}

	while (true)
	{
		Disp("[0] Exit\n");
		Disp("[1] RGB16 bpp (R:5 G:6 B:5)\n");
		Disp("[2] RGB24 bpp (R:8 G:8 B:8)\n");
		Disp("[3] 1 bpp (Palette)\n");
		Disp("[4] 2 bpp (palette)\n");	
		Disp("[5] 4 bpp (Palette)\n");
		Disp("[6] 8 bpp (Palette)\n");				

		Disp("\n");
		Disp("> Select Foreground's Bpp: ");
		uSelBpp = GetIntNum();

		if (uSelBpp == 0)
			return;
		else if (uSelBpp >= 1 && uSelBpp <= 2)
		{
			eFgBpp = (uSelBpp == 1) ? RGB16 : RGB24;

			break;
		}
		else
			Disp("Invalid Input! Retry It!!\n");
	}
}

static void SetArgbBpp(void)
{
	u32 uBgBpp, uSelFgArgb;

	while (true) // Set Background's Bpp
	{
		Disp("[0] Exit\n");
		Disp("[1] RGB16 Bpp (R:5 G:6 B:5)\n");
		Disp("[2] RGB24 Bpp (R:8 G:8 B:8)\n");

		Disp("\n");
		Disp("> Select Background's Bpp: ");
		uBgBpp = GetIntNum();

		if (uBgBpp == 0)
			return;
		else if (uBgBpp >= 1 && uBgBpp <=2)
		{
			eBgBpp = (uBgBpp == 1) ? RGB16 : RGB24;
			break;
		}
		else
			Disp("Invalid Input! Retry It!!\n");
	}

	Disp("\n");
	
	while(true) // Set Foreground's Bpp
	{
		Disp("[0] Exit\n");
		Disp("[1] ARGB 16Bpp (A:1 R:5 G:5 B:5)\n");
		Disp("[2] ARGB 24Bpp (A:1 R:8 G:8 B:7)\n");
		Disp("(\'A\' means ALPHA VALUE when PER-PIXEL BLENDING is tested)\n");					
		Disp("This selection is applied for only PER-PIXEL BLENDING test\n");
		Disp("\n");

		Disp("> Select Foreground's Bpp: ");

		uSelFgArgb = GetIntNum();

		if (uSelFgArgb == 0)
			return;
		else if (uSelFgArgb >= 1 && uSelFgArgb <= 2)
		{
			eFgArgbBpp = (uSelFgArgb == 1) ? ARGB16 : ARGB24;
			break;
		}
		else
			Disp("Invalid Input! Retry It!!\n");
	}
	
}


//-----------------------------------------------------------
// Function Name : SetAllWinBpp
//
// Function Desctiption :
//
// Input :	
//
// Output :
//
// Version : 
//------------------------------------------------------------
static void SetAllWinBpp(void)
{
	u32 uSelWin;
	
	while (true)
	{
		Disp("[0] Exit\n");
		Disp("[1] WIN0: RGB24, WIN1: RGB16, WIN2: PAL4, WIN3: PAL2, WIN4: PAL1\n");
		Disp("[2] WIN0: RGB16, WIN1: RGB24, WIN2: PAL1, WIN3: PAL4, WIN4: PAL2\n");
		Disp("[3] WIN0: RGB24, WIN1: RGB24  WIN2: PAL4, WIN3: PAL4, WIN4: PAL1\n");
		Disp("[4] WIN0: RGB16, WIN1: RGB16, WIN2: PAL2, WIN3: PAL1, WIN4: PAL2\n");

		Disp("\n");
		Disp("Select A Combination Of Windows: ");

		uSelWin = GetIntNum();
		Disp("(Data Format Of Palette: RGB16)\n");
		
		if (uSelWin == 0)
			return;
		else if (uSelWin >= 1 && uSelWin <= 4)
		{
			eWinBpp[0] = (uSelWin == 1 || uSelWin == 3) ? RGB24 : RGB16;
			eWinBpp[1] = (uSelWin == 2 || uSelWin == 3) ? RGB24 : RGB16;
			eWinBpp[2] =
				(uSelWin == 1 || uSelWin == 3) ? PAL4 :
				(uSelWin == 4) ? PAL2 : PAL1;
			eWinBpp[3] =
				(uSelWin == 2 || uSelWin == 3) ? PAL4 :
				(uSelWin == 1) ? PAL2 : PAL1;
			eWinBpp[4] = (uSelWin == 2 || uSelWin == 4) ? PAL2 : PAL1;

			ePalDataBpp = RGB16;
			break;
		}
		else
			Disp("Invalid Input! Retry It!!\n");
	}
}

static void SetPaletteBppAndWin(void)
{
	u32 uSelPalDataBpp, uSelPalBpp;
	u32 uSelWin;
	
	while (true)
	{
		Disp("[0] Exit\n");
		Disp("[1] WIN 0\n");
		Disp("[2] WIN 1\n");
		Disp("[3] WIN 2\n");
		Disp("[4] WIN 3\n");
		Disp("[5] WIN 4\n");

		Disp(">>Select Window Number: ");
		
		uSelWin = GetIntNum();

		if (uSelWin == 0)
			return;
		else if (uSelWin >= 1 && uSelWin <= 5)
		{
			eBgWin =
				(uSelWin == 1) ? WIN0 :
				(uSelWin == 2) ? WIN1 :
				(uSelWin == 3) ? WIN2 :
				(uSelWin == 4) ? WIN3 :	WIN4;
			break;
		}
		else 
			Disp("Invalid Input! Retry It!!\n");
		Disp("\n");
	}

	Disp("\n");
	
	while (true)
	{
		Disp("[0] Exit\n");
		Disp("[1] Paltte 1Bpp\n");
		Disp("[2] Paltte 2Bpp\n");

		if (eBgWin != WIN4)
		{
			Disp("[3] Palette 4Bpp\n");

			if (eBgWin == WIN0 || eBgWin == WIN1)
			{
				Disp("[4] Palette 8Bpp\n");
			}
		}
		Disp(">>Select Palette Bpp: ");

		uSelPalBpp = GetIntNum();

		if (uSelPalBpp == 0)
			return;
		else if ( uSelPalBpp >= 1 && uSelPalBpp <= 4)
		{
			if (eBgWin == WIN0 || eBgWin == WIN1)
			{
				ePalBpp =
					(uSelPalBpp == 1) ? PAL1 :
					(uSelPalBpp == 2) ? PAL2 :
					(uSelPalBpp == 3) ? PAL4 : PAL8;
			}
			else if (eBgWin == WIN2 || eBgWin == WIN3)
			{
				ePalBpp =
					(uSelPalBpp == 1) ? PAL1 :
					(uSelPalBpp == 2) ? PAL2 : PAL4;

				ePalDataBpp = RGB16;
				Disp("Data Format Of Palette is set to RGB 16Bpp\n");
			}
			else 
			{
				ePalBpp = (uSelPalBpp == 1) ? PAL1 : PAL2;
				ePalDataBpp = RGB16;
				Disp("Data Format Of Palette is set to RGB 16Bpp\n");				
			}
			
			break;
		}
		else
			Disp("Invalid Input! Retry It!!\n");

		Disp("\n");
	}

	Disp("\n");
	
	if (eBgWin == WIN0 || eBgWin == WIN1)
	{
		while (true)
		{
			Disp("[0] Exit\n");
			Disp("[1] RGB 16Bpp (R:5 G:6 B:5)\n");
			Disp("[2] RGB 24Bpp (R:8 G:8 B:8)\n");

			Disp(">>Select Data Bpp Of Palette: ");

			uSelPalDataBpp = GetIntNum();

			if (uSelPalDataBpp == 0)
				return;
			else if (uSelPalDataBpp >= 1 && uSelPalDataBpp <= 2)
			{
				ePalDataBpp = (uSelPalDataBpp == 1) ? RGB16 : RGB24;
				break;
			}
			else
				Disp("Invalid Input! Retry It!!\n");
		}	
	}	
}

static void SelectReverseWins(void)
{
	u32 uSelWin;
	u32 uSelBpp;
	const char* pcGrndStr;

	while (true)
	{
		Disp("[0] Exit\n");
		Disp("[1] Background: WIN0, Foreground1: WIN2, Foreground2: WIN1\n");
		Disp("[2] Background: WIN1, Foreground1: WIN0, Foreground2: WIN2\n");
		Disp("[3] Background: WIN1, Foreground1: WIN2, Foreground2: WIN0\n");
		Disp("[4] Background: WIN2, Foreground1: WIN0, Foreground2: WIN1\n");
		Disp("[5] Background: WIN2, Foreground1: WIN1, Foreground2: WIN0\n");		

		Disp(">>Select A Combination Of Windows: ");

		uSelWin = GetIntNum();

		if (uSelWin == 0)
			return;
		else if (uSelWin >= 1 || uSelWin <= 5)
		{
			eBgWin_Rev = 
				(uSelWin == 1) ? WIN0 :
				(uSelWin == 2 || uSelWin == 3) ? WIN1 : WIN2;

			eFgWinArray_Rev[0] =
				(uSelWin == 1 || uSelWin == 3) ? WIN2 :
				(uSelWin == 2 || uSelWin == 4) ? WIN0 : WIN1;

			eFgWinArray_Rev[1] =
				(uSelWin == 1 || uSelWin == 4) ? WIN1 :
				(uSelWin == 2) ? WIN2 : WIN0;

			break;
		}
		else
			Disp("Invalid Input! Retry It!!\n");
	}

	Disp("\n");

	while (true)
	{
		int i=0;
		while (i<3)
		{
			pcGrndStr = 
				(i == 0) ? "Background" :
				(i == 1) ? "Foreground1" : "Foreground2";
				
			Disp("[0] Exit\n");
			Disp("[1] RGB 16Bpp\n");
			Disp("[2] RGB 24Bpp\n");
			Disp(">>Select Bpp Of %s: ", pcGrndStr);

			uSelBpp = GetIntNum();

			if (uSelBpp == 0)
				return;
			else if (uSelBpp >= 1 && uSelBpp<= 2)
			{
				if (i==0)
					eBgBpp_Rev = (uSelBpp == 1) ? RGB16 : RGB24;
				else
					eFgBppArray_Rev[i-1] = (uSelBpp == 1) ? RGB16 : RGB24;
				i++;
			}
			else
				Disp("Invalid Input! Retry It!!\n");

			Disp("\n");
		}
		
		if (i==3)
			break;
	}
}

//////////////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////////////
// LCD Test Functions
//////////////////////////////////////////////////////////////////////////////////////

static void DisBasicRgb(void)
{
	u32 uFgAddr;
	u32 uHSz, uVSz;
	
	bIsRev = false;
	bIsAllWin = false;
	
	Disp("Enter Any Key To Test Simple Display\n");
	UART_Getc();

	LCD_InitDISPC(eBgBpp, uLcdFbAddr, eBgWin, false);
	LCD_SetWinOnOff(1, eBgWin);

	LCD_Start();

	Disp("Window %d (Background) Is Displayed\n", (int)eBgWin);
	LCD_GetFrmSz(&uHSz, &uVSz, eBgWin);
	GLIB_InitInstance(uLcdFbAddr, uHSz, uVSz, eBgBpp);
	GLIB_DrawPattern(uHSz, uVSz);
	GLIB_PutLine(0, 0, 0, uVSz-1, C_BLUE);
	//LCD_Trigger();	// SW trigger in case of  I80 IF

	Disp("Enter Any Key To Display Window %d (Foreground)\n", (int)eFgWin);
	UART_Getc();

	LCD_GetFbEndAddr(&uFgAddr, eBgWin);
	
	LCD_InitWin(eFgBpp, uHSz/2, uVSz/2, 0, 0, uHSz/2, uVSz/2, 60, 80, uFgAddr, eFgWin, false);
	LCD_SetWinOnOff(1, eFgWin);

	Disp("Window %d (Foreground) Is Displayed\n", (int)eFgWin);
	LCD_GetFrmSz(&uHSz, &uVSz, eFgWin);
	GLIB_InitInstance(uFgAddr, uHSz, uVSz, eFgBpp);
	GLIB_DrawPattern2(uHSz, uVSz);
	
	GLIB_PutLine(0, 0, 0, uVSz-1, C_BLUE);	
	//LCD_Trigger();	// SW trigger

	Disp("Enter Any Key To Test Case Which Img. Size Is Smaller\n");
	Disp("Than LCD Size In One Window\n");
	UART_Getc();

	// Test case in which img. size is smaller than LCD size in one window.
	LCD_SetAllWinOnOff(0);
	LCD_InitWin(eBgBpp, uHSz, uVSz, 0, 0, uHSz, uVSz, 60, 80, uLcdFbAddr, eBgWin, false);

	LCD_SetWinOnOff(1, eBgWin);
	
	GLIB_InitInstance(uLcdFbAddr, uHSz, uVSz, eBgBpp);
	GLIB_DrawPattern(uHSz, uVSz);