g2d.c

s3c6400 ADS下官方测试程序

			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(rG2D_INT_PEND_REG));

    Outp32(rG2D_COORD0_X, uPosX);
    Outp32(rG2D_COORD0_Y, uPosY);
    Outp32(rG2D_FG_COLOR, uColor);

    Outp32(rG2D_CMDR0, G2D_REND_POINT_BIT);

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

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


	Outp32(rG2D_COORD0_X, uPosX);
	Outp32(rG2D_COORD0_Y, uPosY);
	Outp32(rG2D_FG_COLOR, uColor);

	Outp32(rG2D_CMDR0, G2D_REND_POINT_BIT);

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


	Outp32(rG2D_COORD0_X, uPosX);
	Outp32(rG2D_COORD0_Y, uPosY);
	Outp32(rG2D_FG_COLOR, uColor);

	Outp32(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);

    Outp32(rG2D_COORD0_X, usPosX1);
    Outp32(rG2D_COORD0_Y, usPosY1);
    Outp32(rG2D_COORD2_X, usPosX2);
    Outp32(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
		}
    }

    Outp32(rG2D_FG_COLOR, uColor);

	uCmdRegVal = 0;

	if(nMajorCoordX)
	{
		Outp32(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);
		Outp32(rG2D_CMDR0, uCmdRegVal);
		while(!bG2dDone);
		bG2dDone=0;

	}
	else
	{
		Outp32(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);
		Outp32(rG2D_CMDR0, uCmdRegVal);
		while(!bG2dDone);
		bG2dDone=0;		
	}
}

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(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=Inp32(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;
	Outp32(rG2D_ROP, uRopRegVal);
}


void G2D_RegisterPattern(u16* uspPattern)
{
	int i;

	G2D_CheckFifo(17);
	if (uspPattern != (u16*)0)
	{
		for(i=0; i<32; i++)
		{
			Outp32( rG2D_PATTERN_ADDR+(i*4), (uspPattern[2*i+1]<<16) | uspPattern[2*i+0]);
		}
	}
	else
		Assert(0); // There is no pattern.
}

void G2D_Set3rdOperand(G2D_OPERAND3 e3rdOp)
{

	u32 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!

	G2D_CheckFifo(17);

	Outp32(rG2D_ROP, (Inp32(rG2D_ROP) &= ~(0x1<<13)) | u3rdOpSel);
}


void G2D_SetRotationMode(u32 uRotationType)
{
	
	G2D_CheckFifo(17);
	Outp32(rG2D_ROT_MODE, (Inp32(rG2D_ROT_MODE) & ~0x3f)|(uRotationType));	
}

void G2D_SetRotationOrg(u16 usRotOrgX, u16 usRotOrgY)
{
	Outp16(rG2D_ROT_OC_X, usRotOrgX);
	Outp16(rG2D_ROT_OC_Y, usRotOrgY);
}

void G2D_SetMaxScreen(u32 uMaxX, u32 uMaxY)
{
	G2D_CheckFifo(17);

	Outp32(rG2D_SC_WINDOW_X, (uMaxX&0x3ff));	
	Outp32(rG2D_SC_WINDOW_Y, (uMaxY&0x3ff));
}

void G2D_SetClippingWindow(u32 uLeftTopX, u32 uLeftTopY, u32 uRightBottomX, u32 uRightBottomY)
{

	G2D_CheckFifo(17);

	Outp32(rG2D_CW_LEFT_TOP_X, uLeftTopX);	
	Outp32(rG2D_CW_LEFT_TOP_Y, uLeftTopY);
	Outp32(rG2D_CW_RIGHT_BOTTOM_X, uRightBottomX);
	Outp32(rG2D_CW_RIGHT_BOTTOM_Y, uRightBottomY);	
}

void G2D_SetPatternMemory(u32 uCoordX, u32 uCoordY, u16 usColor)
{

	u32 uOffsetAddress;
	u32 uData;

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

	uOffsetAddress = uCoordY*8*2 + (uCoordX/2)*4;	
	uData=Inp32(rG2D_PATTERN_ADDR + uOffsetAddress);
	uData = (uData&~(0xffff<<(16*(uCoordX%2))))|(usColor<<(16*(uCoordX%2)));
	Outp32(rG2D_PATTERN_ADDR + uOffsetAddress, uData);	
}

void G2D_GetPatternMemory(u32 uCoordX, u32 uCoordY, u16 *usColor)
{

	u32 uOffsetAddress;
	u32 uData;

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

	uOffsetAddress = uCoordY*8*2 + (uCoordX/2)*4;	
	uData=Inp32(rG2D_PATTERN_ADDR + uOffsetAddress);

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

void G2D_SetPatternOffset(u8 ucPatOffsetX, u8 ucPatOffsetY)
{

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

	G2D_CheckFifo(17);
	Outp32(rG2D_PAT_OFF_X, ucPatOffsetX);
	Outp32(rG2D_PAT_OFF_Y, ucPatOffsetY);
}


void G2D_SetCoordinateDrawingText(u32 uStartX, u32 uStartY, u32 uEndX, u32 uEndY)
{

	G2D_CheckFifo(17);

	Outp32(rG2D_COORD0_X, uStartX);
	Outp32(rG2D_COORD0_Y, uStartY);
	Outp32(rG2D_COORD1_X, uEndX);
	Outp32(rG2D_COORD1_Y, uEndY);	
}

void G2D_SetFirstText(u32 uFirstText)
{
	G2D_CheckFifo(17);

	Outp32(rG2D_CMDR4, uFirstText);
}

void G2D_SetNextText(u32 uNextText)
{
	G2D_CheckFifo(17);

	Outp32(rG2D_CMDR5, uNextText);
}

void G2D_SetCMDR7(u32 uTestDrawingFbAddr)
{
	G2D_CheckFifo(17);

	Outp32(rG2D_CMDR7, uTestDrawingFbAddr);
}

void G2D_SetFontType(u32 uFontType, u32 *uFontWidth, u32 *uFontHeight)
{

	switch(uFontType)
	{
		case 0:
			oG2d.m_upFontType = (u8 *)chr_font8X8;
			oG2d.m_uFontWidth = 8;
			oG2d.m_uFontHeight = 8;
			*uFontWidth=8;
			*uFontHeight=8;
			break;
		case 1:
			oG2d.m_upFontType = (u8 *)font8x15;
			oG2d.m_uFontWidth = 8;
			oG2d.m_uFontHeight = 15;
			*uFontWidth=8;
			*uFontHeight=15;
			break;		
		case 2:
			oG2d.m_upFontType = (u8 *)chr_font8X16T;
			oG2d.m_uFontWidth = 8;
			oG2d.m_uFontHeight = 15;
			*uFontWidth=8;
			*uFontHeight=15;			
			break;
		case 3:
			oG2d.m_upFontType = (u8 *)chr_font8X16;
			oG2d.m_uFontWidth = 8;
			oG2d.m_uFontHeight = 16;
			*uFontWidth=8;
			*uFontHeight=16;			
			break;	
		default:
			oG2d.m_upFontType = (u8 *)chr_font8X8;
			oG2d.m_uFontWidth = 8;
			oG2d.m_uFontHeight = 8;
			*uFontWidth=8;
			*uFontHeight=8;			
			break;
	}
}

void G2D_FillMemoryForTextDrawing(u32 uFontType, u32 uTextDrawingFbAddr)
{
	u8* ucOneLetter;	
	u32 uHostData = 0x0;
	u32 uTempData = 0x0;
	u32 i,j,k;
	
	u32 uTotalSizeOfFont;
	u32 uAddressOffset;

	switch(uFontType) {
		case 0:
			oG2d.m_upFontType = (u8 *)chr_font8X8;
			oG2d.m_uFontWidth = 8;
			oG2d.m_uFontHeight = 8;
			uTotalSizeOfFont=sizeof(chr_font8X8);
			break;
		case 1:
			oG2d.m_upFontType = (u8 *)font8x15;
			oG2d.m_uFontWidth = 8;
			oG2d.m_uFontHeight = 15;
			uTotalSizeOfFont=sizeof(font8x15);
			break;
		case 2:
			oG2d.m_upFontType = (u8 *)chr_font8X16T;
			oG2d.m_uFontWidth = 8;
			oG2d.m_uFontHeight = 15;
			uTotalSizeOfFont=sizeof(chr_font8X16T);		
			break;
		case 3:
			oG2d.m_upFontType = (u8 *)chr_font8X16;
			oG2d.m_uFontWidth = 8;
			oG2d.m_uFontHeight = 16;		
			uTotalSizeOfFont=sizeof(chr_font8X16);
			break;	
		default:
			oG2d.m_upFontType = (u8 *)chr_font8X8;
			oG2d.m_uFontWidth = 8;
			oG2d.m_uFontHeight = 8;
			uTotalSizeOfFont=sizeof(chr_font8X8);	
			break;			
	}

//	*uFontSize = oG2d.m_uFontHeight;
/*
	for(i=0; i< uTotalSizeOfFont/4; i++) {
		ucOneLetter = oG2d.m_upFontType + i*4; // get start address of chosen letter in font8x15
		for (j=0; j<4; j++) // Generate 1-word of data!!
		{
			uTempData = (u32)ucOneLetter[j];
			uHostData |= (uTempData << (24 - 8*j));
		}
		*(unsigned int *)(uTextDrawingFbAddr+i*4)=uHostData;
		uHostData=0;
	}	
*/	
	// oG2d.m_ufontWidth might be multiple of 8.
	uAddressOffset=((oG2d.m_uFontWidth/8*oG2d.m_uFontHeight+3)/4)*4;
	for(i=0; i< (uTotalSizeOfFont)/(oG2d.m_uFontWidth/8*oG2d.m_uFontHeight); i++) {
		ucOneLetter = oG2d.m_upFontType + i*oG2d.m_uFontWidth/8*oG2d.m_uFontHeight; 
		for (j=0; j<(oG2d.m_uFontWidth/8*oG2d.m_uFontHeight+3)/4; j++) // Generate 1-word of data!!
		{
			for (k=0; k<4; k++) // Generate 1-word of data!!
			{
				uTempData = (u32)ucOneLetter[j*4+k];
				uHostData |= (uTempData << (24 - 8*k));
			}
			*(unsigned int *)(uTextDrawingFbAddr+i*uAddressOffset+j*4)=uHostData;
			uHostData=0;
		}

	}

}

void G2D_SetCoordinateSrcBlock(u32 uStartX, u32 uStartY, u32 uEndX, u32 uEndY)
{