g2d.c

samsung 最新芯片2450 的测试程序.

#ifdef INTERRUPT_MODE
				while(!bG2dDone);
				bG2dDone=0;
#endif
		}


		uPosX = uPosX2; //  Set left top X coordinate of next letter
		uPosX2 = uPosX + oG2d.m_uFontWidth - 1; // Set rigth bottom X coordiante of next letter
	}
}


// If bIsHost == 0, Host to screen text drawing
// else if bIsHost == 1, Memory to screen text drawing
void G2D_Printf(u32 uPosX, u32 uPosY, const char* cpFmt, ...)
{
	va_list eAp;
	char cString[256];

	va_start(eAp, cpFmt);
	vsprintf(cString, cpFmt, eAp);
	G2D_PutString(uPosX, uPosY, cString);
	va_end(eAp);
}




//Inserted or Modified by Boaz.kim//

void Basic_Display_2D(void)
{	
	int8 image,window,buffer;
	int8* winbuf;

	winbuf=Select_Win_Buf();
	window=*winbuf;
	buffer=*(winbuf+1);
	if( window<0 || window>1 || buffer<0 || buffer>1)
		return;

	printf("\nSelect the image which you want to display\n");  
	printf(" 0: RGB bar display(24bpp)");
	printf(" 1: 16bpp WVGA Landscape Picture\n");
	
	image = GetIntNum();
	if( image<0 && image>1)
		return;	

	
		
 	printf("\n >>> Display Window: %d, Buffer: %d\n",window,buffer);
 	Make_Image(window, buffer, image);

//	pISR_LCD = (unsigned)Display_ISR1;
//	rINTMSK &= ~(1<<16);

	if(lcd_if==I80_IF)
	{
		rVIDINTCON = (1<<19)|(1<<17)|(1<<0); //Sending complete
		rVIDINTCON |= (1<<0); //enable
		
		rINTSUBMSK &= ~(1<<17);//i80 I/F
	}
	else
	{
		rVIDINTCON = (1<<15)|(1<<12)|(1<<0); //frame
		rVIDINTCON |= (1<<0); //frame

		rINTSUBMSK &= ~(1<<16);//RGB I/F
	}

	Display_Start(window);	

//	Display_End(window);
	
//	rINTMSK |= (1<<16);
	return;
}


void G2D_Init(void) // Adding
{

	u32 uLcdWidth, uLcdHeight;
	CSPACE eBgBpp;
	LCD_WINDOW eBgWin;
	u32 uLcdFbAddr;
	u8 image,window,buffer;

	eBgWin=WIN0;
#if     BPP_Mode==RGB16_Mode
	eBgBpp=RGB16;
#elif  BPP_Mode==RGB24_Mode
	eBgBpp=RGB24;
#endif


	rMISCCR |= (1<<28);  // select LCD controller for TFT lcd controller
	SetLcdPort();
	
	lcd_module=0;
	lcd_type=LANDSCAPE;		// Portrait:0 Landscpe:1
 	lcd_size=WVGA;			// QVGA:0, WVGA:1, ...
 	lcd_if  =PARALLEL_IF;	// Parallel:0, Serial:1, i80:2

	Init_LDI();

	window = 0;
	buffer = 0;
	
	LcdWindowOnOff(LCD_WIN_ALL,LCD_OFF);
	LcdEnvidOnOff(LCD_OFF);  

	Basic_Display_2D();

//	Test_DisplayFramebufferRgbIf_QVGA_2D();

	
	LcdWindowOnOff(LCD_WIN_ALL,LCD_ON);
	GLIB_InitInstance(LCD_FRAME_BUFFER, lcd_horizon_value, lcd_line_value, eBgBpp);

	GLIB_DrawPattern(lcd_horizon_value, lcd_line_value);
	
	GLIB_PutLine(0, 0, 0, lcd_line_value-1, C_BLUE);
	
	LcdEnvidOnOff(LCD_ON);


	printf("lcdwidht=%d, lcdheight=%d\n", lcd_horizon_value, lcd_line_value);
//	G2D_InitSetting(uLcdFbAddr, eBgBpp, uLcdWidth, uLcdHeight, 0, 0, uLcdWidth, uLcdHeight);
//	G2D_InitSetting(0x31000000, RGB16, 320, 240, 0, 0, 320, 240);
	G2D_InitSetting(LCD_FRAME_BUFFER, eBgBpp, lcd_horizon_value, lcd_line_value, 0, 0, lcd_horizon_value, lcd_line_value);


}

void G2D_InitSetting(u32 uFbStAddr, CSPACE eBpp, u32 uCwMaxHSz, u32 uCwMaxVSz,
                                                  u32 uX1_Cw, u32 uY1_Cw, u32 uX2_Cw, u32 uY2_Cw) // modification
{
//	Assert(uCwMaxHSz <= 2040); // Max horizontal size of clipping window should be 2048.
//	Assert(uCwMaxVSz <= 2040); // Max vertical size of clipping window should be 2048.

       printf("BPP:0x%x", eBpp);

	// Initialize color
	switch(eBpp) {
		case RGB16:
			oG2d.m_uColorVal[G2D_BLACK] = 0x0;
			oG2d.m_uColorVal[G2D_RED]   = 0x1f<<11;
			oG2d.m_uColorVal[G2D_GREEN] = 0x3f<<5;
			oG2d.m_uColorVal[G2D_BLUE]  = 0x1f<<0;
			oG2d.m_uColorVal[G2D_WHITE] = 0xffff;
			oG2d.m_uBytes =2;
			 printf("\nRGB16 BPP");
			break;
		case RGBA16: // 15-bpp, The name of ARGB8 should be changed to proper name.
			oG2d.m_uColorVal[G2D_BLACK] = 0x0;
			oG2d.m_uColorVal[G2D_RED]   = (0x1f<<11);
			oG2d.m_uColorVal[G2D_GREEN] =(0x1f<<6);
			oG2d.m_uColorVal[G2D_BLUE]  =(0x1f<<1);
			oG2d.m_uColorVal[G2D_WHITE] =0xffffe;
			oG2d.m_uBytes =2;
			break;
		case ARGB16: // 15-bpp, The name of ARGB8 should be changed to proper name.
			oG2d.m_uColorVal[G2D_BLACK] = 0x0;
			oG2d.m_uColorVal[G2D_RED]   = (0x1f<<10);
			oG2d.m_uColorVal[G2D_GREEN] =(0x1f<<5);
			oG2d.m_uColorVal[G2D_BLUE]  =(0x1f<<0);
			oG2d.m_uColorVal[G2D_WHITE] =0x7fff;
			oG2d.m_uBytes =2;
			break;						
		case RGB24:
		case ARGB24:
			oG2d.m_uColorVal[G2D_BLACK] = 0x0;
			oG2d.m_uColorVal[G2D_RED]   = 0xff0000;
			oG2d.m_uColorVal[G2D_GREEN] = 0xff00;
			oG2d.m_uColorVal[G2D_BLUE]  = 0xff;
			oG2d.m_uColorVal[G2D_WHITE] = 0xffffff;
			oG2d.m_uBytes =4;
			break;
		case RGBX24:
		case RGBA24:		
			oG2d.m_uColorVal[G2D_BLACK] = 0x0;
			oG2d.m_uColorVal[G2D_RED]   = 0xff000000;
			oG2d.m_uColorVal[G2D_GREEN] = 0xff0000;
			oG2d.m_uColorVal[G2D_BLUE]  = 0xff00;
			oG2d.m_uColorVal[G2D_WHITE] = 0xffffff00;
			oG2d.m_uBytes =4;
			break;			
		default:	
			oG2d.m_uColorVal[G2D_BLACK] = 0x0;
			oG2d.m_uColorVal[G2D_RED]   = 0x1f<<11;
			oG2d.m_uColorVal[G2D_GREEN] = 0x3f<<5;
			oG2d.m_uColorVal[G2D_BLUE]  = 0x1f<<0;
			oG2d.m_uColorVal[G2D_WHITE] = 0xffff;
			oG2d.m_uBytes =4;
			break;
	}
	oG2d.m_uFbStAddr = uFbStAddr;

	oG2d.m_uColorVal[G2D_YELLOW] = (oG2d.m_uColorVal[G2D_RED] | oG2d.m_uColorVal[G2D_GREEN]);
	oG2d.m_uColorVal[G2D_CYAN] = (oG2d.m_uColorVal[G2D_GREEN] | oG2d.m_uColorVal[G2D_BLUE]);
	oG2d.m_uColorVal[G2D_MAGENTA] = (oG2d.m_uColorVal[G2D_RED] | oG2d.m_uColorVal[G2D_BLUE]);

	oG2d.m_uHoriRes = uCwMaxHSz;
	oG2d.m_uVertRes = uCwMaxVSz; //new in v2.0

	//oG2d.m_uMaxDx = uCwMaxHSz - 1;
	//oG2d.m_uMaxDy = uCwMaxVSz - 1;

	oG2d.m_uMaxDx = uCwMaxHSz;
	oG2d.m_uMaxDy = uCwMaxVSz;

	oG2d.m_uCwX1 = uX1_Cw;
	oG2d.m_uCwY1 = uY1_Cw;

	oG2d.m_uCwX2 = uX2_Cw - 1;
	oG2d.m_uCwY2 = uY2_Cw - 1;

	//oG2d.m_uCwX2 = uX2_Cw;
	//oG2d.m_uCwY2 = uY2_Cw;
	

	oG2d.m_upFontType = (u8 *)font8x15;
	oG2d.m_uFontWidth = 8;
	oG2d.m_uFontHeight = 15;

	oG2d.m_eBpp = eBpp;

//	oG2d.m_bIsBitBlt = false;
	oG2d.m_bIsBitBlt = true;


	oG2d.m_bIsScr2Scr = false;
	oG2d.m_uFontAddr = (uFbStAddr&0xff000000)+0x800000;

	G2D_DisableEffect(); // Disable per-pixel/per-plane alpha blending and fading
	G2D_SetColorKeyOff();
	G2D_InitRegs(eBpp);
}

void G2D_ClearFrameEcolor(G2D_COLOR eColor, u32 uPosX, u32 uPosY) // modification
{
	G2D_ClearFrame(oG2d.m_uColorVal[eColor],  uPosX, uPosY);
}

void G2D_ClearFrame(u32 uColor, u32 uPosX, u32 uPosY) //modification
{
	int i;

	u16 uTmpColor;

	if(oG2d.m_uBytes == 2)
		uTmpColor = uColor & 0xffff;

	for (i=uPosX+(oG2d.m_uMaxDx+1)*uPosY; i<(oG2d.m_uMaxDx+1)*(oG2d.m_uMaxDy+1); i++)
	{
		if(oG2d.m_uBytes == 4) // RGB24
		(*(volatile u32 *)(oG2d.m_uFbStAddr+i*oG2d.m_uBytes))= uColor;
		else if(oG2d.m_uBytes == 2) // RGB16
		(*(volatile u16 *)(oG2d.m_uFbStAddr+i*oG2d.m_uBytes))= uTmpColor;
		else
//			Assert(0); // Unsupported RGB Format!
			;
	}

}


void G2D_PutPixelEcolor(u32 uPosX, u32 uPosY, G2D_COLOR eColor) //modification
{
	G2D_PutPixel(uPosX, uPosY, oG2d.m_uColorVal[eColor]);
}

#if 0
void G2D_PutPixel(u32 uPosX, u32 uPosY, u32 uColor) //modification
{
	volatile unsigned i;
	volatile unsigned val=0x80000000;
//	G2D_CheckFifo(17);
	G2D_CheckFifo(24);

//	printf("0x%x\n", Inp32_0(rG2D_INT_PEND_REG));

    rG2D_COORD0_X= uPosX;
    rG2D_COORD0_Y= uPosY;
    rG2D_FG_COLOR= uColor;

    rG2D_CMDR0= G2D_REND_POINT_BIT;

//	for(i=0; i<10000; i++);

//	printf("0x%x\n", Inp32_0(rG2D_INT_PEND_REG));
	while(!((rG2D_INT_PEND_REG)&(0x3<<9))==(0x3<<9));	//printf("0x%x\n", Inp32_0(rG2D_INT_PEND_REG));
//	printf("0x%x\n", Inp32_0(rG2D_INT_PEND_REG));
	rG2D_INT_PEND_REG= (val|(3<<9));
	rG2D_INT_PEND_REG= val;
	printf("0x%x\n", rG2D_INT_PEND_REG);	
}
#elif 1
void G2D_PutPixel(u32 uPosX, u32 uPosY, u32 uColor) //modification
{
	volatile unsigned i;
	G2D_CheckFifo(17);


	rG2D_COORD0_X= uPosX;
	rG2D_COORD0_Y= uPosY;
	rG2D_FG_COLOR= uColor;

	rG2D_CMDR0= G2D_REND_POINT_BIT;

	
#ifdef INTERRUPT_MODE
	while(!bG2dDone) ;
	bG2dDone=0;
#endif
}
#else
void G2D_PutPixel(u32 uPosX, u32 uPosY, u32 uColor) //modification
{
	volatile unsigned i;
	G2D_CheckFifo(17);


	rG2D_COORD0_X= uPosX;
	rG2D_COORD0_Y= uPosY;
	rG2D_FG_COLOR= uColor;

	rG2D_CMDR0= G2D_REND_POINT_BIT;
}

#endif


void G2D_PutLineEcolor(u16 usPosX1, u16 usPosY1, u16 usPosX2, u16 usPosY2, G2D_COLOR eColor, bool bIsDrawLastPoint) //modification
{
	G2D_PutLine(usPosX1, usPosY1, usPosX2, usPosY2, oG2d.m_uColorVal[eColor], bIsDrawLastPoint);
}

void G2D_PutLine(u16 usPosX1, u16 usPosY1, u16 usPosX2, u16 usPosY2, u32 uColor, bool bIsDrawLastPoint) //modification
{
    int nMajorCoordX;
    u16 uHSz, uVSz;
    int i;
    int nIncr=0;
	u32 uCmdRegVal;

	G2D_CheckFifo(17);


    rG2D_COORD0_X= usPosX1;
    rG2D_COORD0_Y= usPosY1;
    rG2D_COORD2_X= usPosX2;
    rG2D_COORD2_Y= usPosY2;

    uVSz = ABS(usPosY1 - usPosY2);
    uHSz = ABS(usPosX1 - usPosX2);

    nMajorCoordX = (uHSz>=uVSz);

	if(nMajorCoordX)
	{
		for (i=0; i<12; i++)
		{
	    	uVSz <<= 1;
	    	nIncr <<= 1;
	    	if (uVSz >= uHSz)
	    	{
				nIncr = nIncr | 1;
				uVSz -= uHSz;
	    	}
		}
		nIncr = (nIncr + 1) >> 1;
		if (usPosY1 > usPosY2)
		{
	    	nIncr = (~nIncr) + 1; // 2's complement
		}
    }
	else
	{
		for (i=0; i<12; i++)
		{
	    	uHSz <<= 1;
	    	nIncr <<= 1;
	    	if (uHSz >= uVSz)
	    	{
				nIncr = nIncr | 1;
				uHSz -= uVSz;
	    	}
		}
		nIncr = (nIncr + 1) >> 1;
		if (usPosX1 > usPosX2)
		{
	    	nIncr = (~nIncr) + 1; // 2's complement
		}
    }

    rG2D_FG_COLOR= uColor;

	uCmdRegVal = 0;

	if(nMajorCoordX)
	{
		rG2D_Y_INCR= nIncr;
		uCmdRegVal =
			(bIsDrawLastPoint == true) ? (G2D_REND_LINE_BIT | G2D_MAJOR_COORD_X_BIT & G2D_DRAW_LAST_POINT_BIT) :
			(G2D_REND_LINE_BIT | G2D_MAJOR_COORD_X_BIT | G2D_NOT_DRAW_LAST_POINT_BIT);
		rG2D_CMDR0= uCmdRegVal;
#ifdef INTERRUPT_MODE
		while(!bG2dDone);
		bG2dDone=0;
#endif

	}
	else
	{
		rG2D_X_INCR= nIncr;
		uCmdRegVal =
			(bIsDrawLastPoint == true) ? (G2D_REND_LINE_BIT | G2D_MAJOR_COORD_Y_BIT & G2D_DRAW_LAST_POINT_BIT) :
			(G2D_REND_LINE_BIT | G2D_MAJOR_COORD_X_BIT | G2D_NOT_DRAW_LAST_POINT_BIT);
		rG2D_CMDR0= uCmdRegVal;
#ifdef INTERRUPT_MODE
		while(!bG2dDone);
		bG2dDone=0;
#endif

	}
}

void G2D_PutRectangleEcolor(u32 uStPosX, u32 uStPosY, u32 uWidth, u32 uHeight, G2D_COLOR eColor) //modification
{
	G2D_PutRectangle(uStPosX,  uStPosY,  uWidth, uHeight, oG2d.m_uColorVal[eColor]);
}

void G2D_PutRectangle(u32 uStPosX, u32 uStPosY, u32 uWidth, u32 uHeight, u32 uColor) //modification
{

	u32 uEndPosX = uStPosX + uWidth - 1;
	u32 uEndPosY = uStPosY + uHeight - 1;

	G2D_PutLine(uStPosX,  uStPosY,  uEndPosX, uStPosY,  uColor, true);
	G2D_PutLine(uEndPosX, uStPosY,  uEndPosX, uEndPosY, uColor, true);
	G2D_PutLine(uStPosX,  uEndPosY, uEndPosX, uEndPosY, uColor, true);
	G2D_PutLine(uStPosX,  uStPosY,  uStPosX,  uEndPosY, uColor, true);
}

void G2D_FillRectangleEcolor(u32 uStPosX, u32 uStPosY, u32 uWidth , u32 uHeight, G2D_COLOR eColor) //modification
{
	G2D_FillRectangle(uStPosX,  uStPosY, uWidth,   uHeight, oG2d.m_uColorVal[eColor]);
}

void G2D_FillRectangle(u32 uStPosX, u32 uStPosY, u32 uWidth, u32 uHeight, u32 uColor) //modification
{
	int i;
	u32 uEndPosX = uStPosX + uWidth - 1;
	u32 uEndPosY = uStPosY + uHeight - 1;

	for(i=uStPosY; i<=uEndPosY; i++)
		G2D_PutLine(uStPosX, i, uEndPosX, i, uColor, true);
}

void G2D_SetRop(u32 uRopVal)
{
	G2D_CheckFifo(17);
//	Outp32(rG2D_ROP, (Inp32_0(rG2D_ROP)&=~0xff) | uRopVal);
	rG2D_ROP=(rG2D_ROP&~(0xff)|uRopVal);
}

// Set Ternary Raster Operation
// Only support 7 raster operation (most used Rop)
void G2D_SetRopEtype(G2D_ROP_TYPE eRopType)
{
	u32 uRopRegVal;
	u32 uRopVal;

	G2D_CheckFifo(17);

	uRopRegVal=rG2D_ROP;

	uRopVal =
		(eRopType == ROP_SRC_ONLY) ? G2D_ROP_SRC_ONLY :
		(eRopType == ROP_DST_ONLY) ? G2D_ROP_DST_ONLY :
		(eRopType == ROP_3RD_OPRND_ONLY) ? G2D_ROP_3RD_OPRND_ONLY :
		(eRopType == ROP_SRC_AND_DST) ? G2D_ROP_SRC_AND_DST:
		(eRopType == ROP_SRC_OR_3RD_OPRND) ? G2D_ROP_SRC_OR_3RD_OPRND :
		(eRopType == ROP_SRC_AND_3RD_OPRND) ? G2D_ROP_SRC_AND_3RD_OPRND :
		(eRopType == ROP_SRC_XOR_3RD_OPRND) ? G2D_ROP_SRC_XOR_3RD_OPRND :
		(eRopType == ROP_SRC_OR_DST) ? G2D_ROP_SRC_OR_DST : 
		(eRopType == ROP_DST_OR_3RD) ? G2D_ROP_DST_OR_3RD_OPRND : G2D_ROP_SRC_ONLY;

	uRopRegVal = (uRopRegVal&(~0xff))|uRopVal;
	rG2D_ROP= uRopRegVal;
}


void G2D_RegisterPattern(u16* uspPattern)
{
	int i;

	G2D_CheckFifo(17);