fimgse2d.cpp

Samsung公司S3C6400芯片的BSP源码包

		uPosX = uPosX2; //  Set left top X coordinate of next letter
		uPosX2 = uPosX + 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 FIMGSE2D::Printf(DWORD uPosX, DWORD uPosY, const char* cpFmt, ...)
{
	va_list eAp;
	char cString[256];

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



void FIMGSE2D::InitColor(CSPACE eBpp)
{
	switch(eBpp) {
		case ARGB8: // 15-bpp, The name of ARGB8 should be changed to proper name.
			m_uColorVal[G2D_BLACK] = 0x0;
			m_uColorVal[G2D_RED]   = (0x1f<<10);
			m_uColorVal[G2D_GREEN] =(0x1f<<5);
			m_uColorVal[G2D_BLUE]  =(0x1f<<0);
			m_uColorVal[G2D_WHITE] =0x7fff;
			break;
		case RGB16:
			m_uColorVal[G2D_BLACK] = 0x0;
			m_uColorVal[G2D_RED]   = 0x1f<<11;
			m_uColorVal[G2D_GREEN] = 0x3f<<5;
			m_uColorVal[G2D_BLUE]  = 0x1f<<0;
			m_uColorVal[G2D_WHITE] = 0xffff;
			break;
		case RGB18:
			m_uColorVal[G2D_BLACK] = 0x0;
			m_uColorVal[G2D_RED]   = 0x3f<<12;
			m_uColorVal[G2D_GREEN] = 0x3f<<6;
			m_uColorVal[G2D_BLUE]  = 0x3f<<0;
			m_uColorVal[G2D_WHITE] = 0xffff;
			break; 
		case RGB24:
			m_uColorVal[G2D_BLACK] = 0x0;
			m_uColorVal[G2D_RED]   = 0xff0000;
			m_uColorVal[G2D_GREEN] = 0xff00;
			m_uColorVal[G2D_BLUE]  = 0xff;
			m_uColorVal[G2D_WHITE] = 0xffffff;
			break;
		default:	
			m_uColorVal[G2D_BLACK] = 0x0;
			m_uColorVal[G2D_RED]   = 0x1f<<11;
			m_uColorVal[G2D_GREEN] = 0x3f<<5;
			m_uColorVal[G2D_BLUE]  = 0x1f<<0;
			m_uColorVal[G2D_WHITE] = 0xffff;
			Assert(0);
			break;
	}
	m_uColorVal[G2D_YELLOW] = (m_uColorVal[G2D_RED] | m_uColorVal[G2D_GREEN]);
	m_uColorVal[G2D_CYAN] = (m_uColorVal[G2D_GREEN] | m_uColorVal[G2D_BLUE]);
	m_uColorVal[G2D_MAGENTA] = (m_uColorVal[G2D_RED] | m_uColorVal[G2D_BLUE]);
	
}

void FIMGSE2D::SetHoriRes(DWORD horires)
{
	m_uHoriRes = horires;
	m_pG2DReg->HORI_RES = m_uHoriRes;	//lcdX should be 4n	
}

void FIMGSE2D::SetFbAddr(DWORD uFbAddr)	
{
	m_uFbStAddr = uFbAddr;
	m_pG2DReg->FB_BA = m_uFbStAddr;	
}

void FIMGSE2D::SetColorMode(CSPACE eBpp)
{
	DWORD uBppMode;
	uBppMode = (eBpp == ARGB8) ? G2D_COLOR_15BPP_BIT :
				(eBpp == RGB16) ? G2D_COLOR_16BPP_BIT :
				(eBpp == RGB18) ? G2D_COLOR_18BPP_BIT :
				(eBpp == RGB24) ? G2D_COLOR_24BPP_BIT :	G2D_COLOR_24BPP_BIT;

	m_pG2DReg->COLOR_MODE = uBppMode;
}

//	uFbStAddr = _DRAM_BaseAddress+0x04000000;
//	eBpp = 泅犁 祸惑 depth
//	uCwMaxHSz =LCD Width
//	uCwMaxVSz = LCD Height
//	uX1_Cw = 0
//	uY1_Cw = 0
//	uX2_Cw = Lcd Width
//	uY2_Cw = LCD Height
void FIMGSE2D::InitSetting(DWORD uFbStAddr, CSPACE eBpp, DWORD uCwMaxHSz, DWORD uCwMaxVSz, DWORD uX1_Cw, DWORD uY1_Cw, DWORD uX2_Cw, DWORD uY2_Cw) // modification
{
#if HW_PROBE	// For check HW consume time, insert GPIO LED triggering code.
	// GPIO Virtual alloc
	if(g_pGPIORegs == NULL)
	{
		g_pGPIORegs = (volatile S3C6400_GPIO_REG *)DrvLib_MapIoSpace(S3C6400_BASE_REG_PA_GPIO, sizeof(S3C6400_GPIO_REG), FALSE);
	}
	if (g_pGPIORegs == NULL)
	{
		RETAILMSG(1,(TEXT("[GPIO] g_pGPIORegs: VirtualAlloc failed!\r\n")));
		DrvLib_UnmapIoSpace((PVOID)g_pGPIORegs);
		g_pGPIORegs = NULL;
	}
//	g_pGPIORegs->GPNPUD &= ~(0xff<<24);	// Pull Up/Down Disable
//	g_pGPIORegs->GPNCON = (g_pGPIORegs->GPNCON & ~(0xff<<24)) | (0x55<<24);	// GPN[15:14] set to output

#endif

	Assert(uCwMaxHSz <= 2048); // Max horizontal size of clipping window should be 2048.
	Assert(uCwMaxVSz <= 2048); // Max vertical size of clipping window should be 2048.
	RETAILMSG (0, (TEXT("FIMGSE2D:: FbStAddr : %x, eBpp : %d, MaxH : %d, MaxV : %d, X1:%d, Y1:%d, X2:%d, Y2:%d\r\n"), uFbStAddr, eBpp, uCwMaxHSz, uCwMaxVSz, uX1_Cw, uY1_Cw, uX2_Cw, uY2_Cw));
	// Initialize color
	InitColor(eBpp);

	SetFbAddr(uFbStAddr);	
	SetHoriRes(uCwMaxHSz);
	SetMaxScreen(uCwMaxHSz - 1, uCwMaxVSz - 1);	
	SetClippingWindow(uX1_Cw, uY1_Cw, uX2_Cw -1, uY2_Cw -1);

	m_uBytes = (eBpp == RGB16) ? 2 : 4;

	/// Font Operation Related
//	m_upFontType = (BYTE *)font8x15;
	m_uFontWidth = 8;
	m_uFontHeight = 15;
	m_bIsBitBlt = true;	
	m_bIsScr2Scr = false;
	m_uFontAddr = (uFbStAddr&0xff000000)+0x800000;

	SetColorMode(eBpp);

	DisableEffect(); // Disable per-pixel/per-plane alpha blending and fading
	SetColorKeyOff();

	m_pG2DReg->ALPHA = (FADING_OFFSET_DISABLE | ALPHA_VALUE_DISABLE);
	SetFgEcolor(G2D_WHITE); // set color to both font and foreground color
	SetBgEcolor(G2D_BLACK);
	SetBsColor(m_uColorVal[G2D_BLUE]); // Set blue color to blue screen color

	m_pG2DReg->ROP = (G2D_OPERAND3_FG_BIT | G2D_NO_ALPHA_BIT | OPAQUE_ENABLE | G2D_ROP_SRC_ONLY);

	SetRotationOrg(0, 0);
	m_pG2DReg->ROT_MODE = G2D_ROTATION_0_DEG_BIT;
	m_pG2DReg->ALPHA = 0;
	SetReadSize(0x0);				// Read Burst Size
	m_pG2DReg->ENDIAN_READSIZE |= (0x1 << 2);	// HW read buffer size enable
}

void FIMGSE2D::PutPixelEcolor(DWORD uPosX, DWORD uPosY, G2D_COLOR eColor) //modification
{
	PutPixel(uPosX, uPosY, m_uColorVal[eColor]);
}

void FIMGSE2D::PutPixel(DWORD uPosX, DWORD uPosY, DWORD uColor) //modification
{


	m_pG2DReg->COORD0_X = uPosX;
	m_pG2DReg->COORD0_Y = uPosY;
	m_pG2DReg->FG_COLOR = uColor;

	CheckFifo(1);			
	InterruptEnable();							

	m_pG2DReg->CMDR0 = G2D_REND_POINT_BIT;

	while(!WaitForFinish());		
	InterruptDisable();

}

/**
 * Draw Line
 * (usPosX1, usPosY1) ~ (usPosX2, usPosY2)
 * Do not draw last point
 *   0 < usPosX, usPosY1, usPosX2, usPosY2 < 2048
 */
void FIMGSE2D::PutLine(DWORD usPosX1, DWORD usPosY1, DWORD usPosX2, DWORD usPosY2, DWORD uColor, bool bIsDrawLastPoint) //modification
{
	int nMajorCoordX;
	DWORD uHSz, uVSz;
	int i;
	int nIncr=0;
	DWORD uCmdRegVal;

	CheckFifo(1);			

	m_pG2DReg->COORD0_X = usPosX1;
	m_pG2DReg->COORD0_Y = usPosY1;
	m_pG2DReg->COORD2_X = usPosX2;
	m_pG2DReg->COORD2_Y = usPosY2;	

//	printf("COORD0_X: %d, COORD0_Y:%d, COORD2_X:%d, COORD2_Y:%d\n", 
//			m_pG2DReg->COORD0 & (0x7ff),
//			(m_pG2DReg->COORD0 & (0x7ff<<16)) >> 16,			
//			m_pG2DReg->COORD2 & (0x7ff),
//			(m_pG2DReg->COORD2 & (0x7ff<<16)) >> 16);			

	uVSz = ABS((WORD)usPosY1 - (WORD)usPosY2);
	uHSz = ABS((WORD)usPosX1 - (WORD)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
		}
//		printf("pre YINCR: %x  ", nIncr );						
  }
	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
		}
//		printf("pre XINCR: %x  ", nIncr );				
	}

	m_pG2DReg->FG_COLOR = uColor;

	uCmdRegVal = 0;

	if(nMajorCoordX)
	{
		m_pG2DReg->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);
		
//		printf("CMD: %x, XINCR: %x, YINCR: %x\n", uCmdRegVal, m_pG2DReg->X_INCR, m_pG2DReg->Y_INCR );				
		InterruptEnable();							

		m_pG2DReg->CMDR0 = uCmdRegVal;

		while(!WaitForFinish());		
		InterruptDisable();

	}
	else
	{
		m_pG2DReg->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_Y_BIT | G2D_NOT_DRAW_LAST_POINT_BIT);

//		printf("CMD: %x, XINCR: %x, YINCR: %x\n", uCmdRegVal, m_pG2DReg->X_INCR, m_pG2DReg->Y_INCR );		
		InterruptEnable();							

		m_pG2DReg->CMDR0 = uCmdRegVal;

		while(!WaitForFinish());		
		InterruptDisable();
	}
}

void FIMGSE2D::SetRopValue(DWORD uRopVal)
{
	m_pG2DReg->ROP = ((m_pG2DReg->ROP)&(~0xff)) | uRopVal;
}

// Set Ternary Raster Operation
// Only support 7 raster operation (most used Rop)
void FIMGSE2D::SetRopEtype(G2D_ROP_TYPE eRopType)
{
	DWORD uRopRegVal;
	DWORD uRopVal;

	uRopRegVal = m_pG2DReg->ROP;

	uRopVal =
		(eRopType == ROP_SRC_ONLY) ? G2D_ROP_SRC_ONLY :
		(eRopType == ROP_DST_ONLY) ? G2D_ROP_DST_ONLY :
		(eRopType == ROP_PAT_ONLY) ? G2D_ROP_PAT_ONLY :
		(eRopType == ROP_SRC_AND_DST) ? G2D_ROP_SRC_AND_DST:
		(eRopType == ROP_SRC_AND_PAT) ? G2D_ROP_SRC_AND_PAT :		
		(eRopType == ROP_DST_AND_PAT) ? G2D_ROP_DST_AND_PAT :
		(eRopType == ROP_SRC_OR_DST) ? G2D_ROP_SRC_OR_DST :
		(eRopType == ROP_SRC_OR_PAT) ? G2D_ROP_SRC_OR_PAT :		
		(eRopType == ROP_DST_OR_PAT) ? G2D_ROP_DST_OR_PAT :		
		(eRopType == ROP_SRC_XOR_DST) ? G2D_ROP_SRC_XOR_DST :
		(eRopType == ROP_SRC_XOR_PAT) ? G2D_ROP_SRC_XOR_PAT :
		(eRopType == ROP_DST_XOR_PAT) ? G2D_ROP_DST_XOR_PAT :
	 	G2D_ROP_SRC_ONLY;

	uRopRegVal = (uRopRegVal&(~0xff))|uRopVal;
	m_pG2DReg->ROP = uRopRegVal;
}


void FIMGSE2D::RegisterPattern(WORD* uspPattern)
{
	int i;

	CheckFifo(17);
	if (uspPattern != (WORD*)0)
	{
		for(i=0; i<32; i++)
		{
			m_pG2DReg->PATTERN_ADDR[i*4] = (uspPattern[2*i+1]<<16) | uspPattern[2*i+0];
		}
	}
	else
		Assert(0); // There is no pattern.
}

void FIMGSE2D::Set3rdOperand(G2D_OPERAND3 e3rdOp)
{

	DWORD u3rdOpSel =
		(e3rdOp == G2D_OPERAND3_PAT) ? G2D_OPERAND3_PAT_BIT :
		(e3rdOp == G2D_OPERAND3_FG) ? G2D_OPERAND3_FG_BIT :	 0xffffffff;

	if (u3rdOpSel == 0xffffffff) 
		Assert(0); // UnSupported Third Operand!

//	CheckFifo(17);

	m_pG2DReg->ROP = ((m_pG2DReg->ROP) & ~(0x1<<13)) | u3rdOpSel;
}


void FIMGSE2D::SetRotationMode(DWORD uRotationType)
{
	m_pG2DReg->ROT_MODE = ((m_pG2DReg->ROT_MODE) & ~0x3f)|(uRotationType);	
}

void FIMGSE2D::SetRotationOrg(WORD usRotOrgX, WORD usRotOrgY)
{
	SetRotationOrgX(usRotOrgX);
	SetRotationOrgY(usRotOrgY);
}

void FIMGSE2D::SetMaxScreen(DWORD uMaxX, DWORD uMaxY)
{
	m_uMaxDx = uMaxX;
	m_uMaxDy = uMaxY;
	m_pG2DReg->SC_WINDOW_X = (m_uMaxDx & 0x3ff);
	m_pG2DReg->SC_WINDOW_Y = (m_uMaxDy & 0x3ff);
}

void FIMGSE2D::SetClippingWindow(DWORD uLeftTopX, DWORD uLeftTopY, DWORD uRightBottomX, DWORD uRightBottomY)
{
	m_uCwX1 = uLeftTopX;
	m_uCwY1 = uLeftTopY;
	m_uCwX2 = uRightBottomX;
	m_uCwY2 = uRightBottomY;
	
	m_pG2DReg->CW_LEFT_TOP_X = m_uCwX1;	
	m_pG2DReg->CW_LEFT_TOP_Y = m_uCwY1;
	m_pG2DReg->CW_RIGHT_BOTTOM_X = m_uCwX2;
	m_pG2DReg->CW_RIGHT_BOTTOM_Y = m_uCwY2;	
}

void FIMGSE2D::SetPatternMemory(DWORD uCoordX, DWORD uCoordY, WORD usColor)
{

	DWORD uOffsetAddress;
	DWORD uData;

	CheckFifo(17);
	
	Assert(uCoordX <= 7);
	
	Assert(uCoordY <= 7);

	uOffsetAddress = uCoordY*8*2 + (uCoordX/2)*4;	
	uData = m_pG2DReg->PATTERN_ADDR[uOffsetAddress];
	uData = (uData&~(0xffff<<(16*(uCoordX%2))))|(usColor<<(16*(uCoordX%2)));
	m_pG2DReg->PATTERN_ADDR[uOffsetAddress] = uData;
}

void FIMGSE2D::GetPatternMemory(DWORD uCoordX, DWORD uCoordY, WORD *usColor)
{

	DWORD uOffsetAddress;
	DWORD uData;

	CheckFifo(17);
	
	Assert(uCoordX <= 7);
	
	Assert(uCoordY <= 7);

	uOffsetAddress = uCoordY*8*2 + (uCoordX/2)*4;	
	uData = m_pG2DReg->PATTERN_ADDR[uOffsetAddress];

	if((uCoordX%2)==0) *usColor= (WORD)(uData&0xffff);
	else *usColor= (WORD)((uData&0xffff0000)>>16);
	
}

void FIMGSE2D::SetPatternOffset(BYTE ucPatOffsetX, BYTE ucPatOffsetY)
{

	Assert(ucPatOffsetX<=7);
	Assert(ucPatOffsetY<=7);

	CheckFifo(17);
	m_pG2DReg->PAT_OFF_X = ucPatOffsetX;
	m_pG2DReg->PAT_OFF_Y = ucPatOffsetY;
}


void FIMGSE2D::SetCoordinateDrawingText(DWORD uStartX, DWORD uStartY, DWORD uEndX, DWORD uEndY)
{
	SetCoordinateSrcBlock(uStartX, uStartY, uEndX, uEndY);
}

void FIMGSE2D::SetFirstText(DWORD uFirstText)
{
//	CheckFifo(17);

	m_pG2DReg->CMDR4 = uFirstText;
}

void FIMGSE2D::SetNextText(DWORD uNextText)
{
//	CheckFifo(17);

	m_pG2DReg->CMDR5 = uNextText;
}

void FIMGSE2D::SetCMDR7(DWORD uTestDrawingFbAddr)
{
//	CheckFifo(17);

	m_pG2DReg->CMDR7 = uTestDrawingFbAddr;
}
/*
void FIMGSE2D::SetFontType(DWORD uFontType, DWORD *uFontWidth, DWORD *uFontHeight)
{

	switch(uFontType)
	{
		case 0:
			m_upFontType = (BYTE *)chr_font8X8;
			m_uFontWidth = 8;
			m_uFontHeight = 8;
			*uFontWidth=8;
			*uFontHeight=8;
			break;
		case 1:
			m_upFontType = (BYTE *)font8x15;
			m_uFontWidth = 8;
			m_uFontHeight = 15;
			*uFontWidth=8;
			*uFontHeight=15;
			break;		
		case 2:
			m_upFontType = (BYTE *)chr_font8X16T;