fimgse2d.cpp

SAMSUNG S3C6410 CPU BSP for winmobile6

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

		m_pG2DReg->CMDR0 = uCmdRegVal;

		while(!WaitForFinish());		
		IntDisable();

	}
	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 );		
		IntEnable();							

		m_pG2DReg->CMDR0 = uCmdRegVal;

		while(!WaitForFinish());		
		IntDisable();
	}
}

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::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::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::SetCoordinateSrcBlock(DWORD uStartX, DWORD uStartY, DWORD uEndX, DWORD uEndY)
{
//	CheckFifo(17);
	m_pG2DReg->COORD0_X = uStartX;
	m_pG2DReg->COORD0_Y = uStartY;
	m_pG2DReg->COORD1_X = uEndX;
	m_pG2DReg->COORD1_Y = uEndY;	
}

void FIMGSE2D::SetCoordinateDstBlock(DWORD uStartX, DWORD uStartY, DWORD uEndX, DWORD uEndY)
{
//	CheckFifo(17);
	m_pG2DReg->COORD2_X = uStartX;
	m_pG2DReg->COORD2_Y = uStartY;
	m_pG2DReg->COORD3_X = uEndX;
	m_pG2DReg->COORD3_Y = uEndY;	
}

void FIMGSE2D::SetFirstBitBLTData(DWORD uFirstData)
{
	CheckFifo(17);

	m_pG2DReg->CMDR2 = uFirstData;
}

void FIMGSE2D::SetNextBitBLTData(DWORD uNextData)
{
	CheckFifo(17);

	m_pG2DReg->CMDR3 = uNextData;
}

void FIMGSE2D::SetStencilKey(DWORD uIsColorKeyOn, DWORD uIsInverseOn, DWORD uIsSwapOn)
{	
	m_pG2DReg->COLORKEY_CNTL = ((uIsColorKeyOn&1)<<31)|((uIsInverseOn&1)<<23)|(uIsSwapOn&1);
}

void FIMGSE2D::SetStencilMinMax(DWORD uRedMin, DWORD uRedMax, DWORD uGreenMin, DWORD uGreenMax, DWORD uBlueMin, DWORD uBlueMax)
{
	m_pG2DReg->COLORKEY_DR_MIN = ((uRedMin&0xff)<<16)|((uGreenMin&0xff)<<8)|(uBlueMin&0xff);
	m_pG2DReg->COLORKEY_DR_MAX = ((0xffU<<24)|(uRedMax&0xff)<<16)|((uGreenMax&0xff)<<8)|(uBlueMax&0xff);	
}

void FIMGSE2D::GetFrmSz(DWORD *uG2dWidth, DWORD *uG2dHeight)
{
	DWORD uMaxScreenVal;

	uMaxScreenVal = m_pG2DReg->SC_WINDOW;
	*uG2dWidth = (uMaxScreenVal&0x7ff)+1;
	*uG2dHeight = ((uMaxScreenVal>>16)&0x7ff)+1;
}

void FIMGSE2D::GetFbAddr(DWORD *uG2dFbAddr)
{
	*uG2dFbAddr = m_pG2DReg->FB_BA;
}

void FIMGSE2D::GetBppMode(CSPACE *eBpp)
{
	DWORD uBppVal;

	uBppVal = m_pG2DReg->COLOR_MODE;
	switch(uBppVal&0xf) {
		case 1:
			*eBpp=ARGB8; //15-bpp
			break;
		case 2:
			*eBpp=RGB16; //16-bpp
			break;
		case 4:
			*eBpp=RGB18; // 18-bpp
			break;
		case 8:
			*eBpp=RGB24; // 24-bpp
			break; 
		default:
			*eBpp=RGB16; //16-bpp
			break;
	}		
}

void FIMGSE2D::SetColorExpansionMethod(bool bIsScr2Scr)
{
	m_bIsScr2Scr  = (bIsScr2Scr) ? 1 :	0;
}

void FIMGSE2D::IntEnable(void)
{
	m_pG2DReg->INTEN = (0x1<<9);// + (0x1<<8) + (0x1);				//Enable Interrupt
	m_pG2DReg->INTC_PEND = 0x80000000;		//

	bG2dDone=0;
}

void FIMGSE2D::IntDisable(void)
{
	m_pG2DReg->INTEN &= ~((1<<9) /*+(1<<8) + 1*/);//Disable Interrupt
}

void FIMGSE2D::IntPendingClear(void)
{
	m_pG2DReg->INTC_PEND = 0x80000701;		// Level Interrupt (Interupt Clear Enable)
	m_pG2DReg->INTC_PEND = 0x80000000;		// Level Interrupt (Interupt Clear Enable)	
}

void FIMGSE2D::SetEndian(bool bEndian)
{
	m_pG2DReg->ENDIAN_READSIZE = ( (m_pG2DReg->ENDIAN_READSIZE) & ~(1<<4)) | (bEndian<<4);
}
void FIMGSE2D::SetReadSize(BYTE ucReadSize)
{
	m_pG2DReg->ENDIAN_READSIZE = ( (m_pG2DReg->ENDIAN_READSIZE) & ~(3<<0) ) | ucReadSize ;
}

void FIMGSE2D::ConvertEcolorToRaw(G2D_COLOR eColor, DWORD *uRawColor) 
{
	*uRawColor=m_uColorVal[eColor];
}

void FIMGSE2D::GetFbData(DWORD uX, DWORD uY, DWORD uG2dWidth, DWORD uG2dFbAddr, CSPACE eBpp, DWORD *uFbData)
	 
{
	if(eBpp==RGB24 || eBpp==RGB18)
		*uFbData = *(DWORD *)(uG2dFbAddr+(uY*uG2dWidth+uX)*4);
	else
		*uFbData = *(WORD *)(uG2dFbAddr+(uY*uG2dWidth+uX)*2) & 0xFFFF;
}

void FIMGSE2D::SetFbData(DWORD uX, DWORD uY, DWORD uG2dWidth, DWORD uG2dFbAddr, CSPACE eBpp, DWORD uFbData)
	 
{
	if(eBpp==RGB24 || eBpp==RGB18)
		*(DWORD *)(uG2dFbAddr+(uY*uG2dWidth+uX)*4) = uFbData;
	else
		*(WORD *)(uG2dFbAddr+(uY*uG2dWidth+uX)*2) = (WORD)uFbData;
}

void FIMGSE2D::ConvertPatternToRaw(WORD uThirdDataOrg, CSPACE eBpp, DWORD *uThirdDataConverted)
{
	DWORD uRed, uGreen, uBlue;
	switch(eBpp) {
		case RGB16:
			*uThirdDataConverted=uThirdDataOrg;
			break;
		case RGB18:
			uRed=(((uThirdDataOrg>>11)&0x1f)<<(12+1));
			uGreen=(((uThirdDataOrg>>5)&0x3f)<<6);
			uBlue=((uThirdDataOrg&0x1f)<<(0+1));
			*uThirdDataConverted=(uRed|uGreen|uBlue);
			if(*uThirdDataConverted&0x02000) *uThirdDataConverted|=0x01000;
			if(*uThirdDataConverted&0x00040) *uThirdDataConverted=*uThirdDataConverted;
			if(*uThirdDataConverted&0x00002) *uThirdDataConverted|=0x1;			
			break;
		case RGB24:
			uRed=(((uThirdDataOrg>>11)&0x1f)<<(16+3));
			uGreen=(((uThirdDataOrg>>5)&0x3f)<<(8+2));
			uBlue=((uThirdDataOrg&0x1f)<<(0+3));
			*uThirdDataConverted=(uRed|uGreen|uBlue);
			if(*uThirdDataConverted&0x00080000) *uThirdDataConverted|=0x00070000;
			if(*uThirdDataConverted&0x00000400) *uThirdDataConverted|=0x00000300;
			if(*uThirdDataConverted&0x00000008) *uThirdDataConverted|=0x00000007;			
			break;
		default:
			*uThirdDataConverted=uThirdDataOrg;
			break;

	}

}


void FIMGSE2D::BlendingOut(DWORD uSrcData, DWORD uDstData, BYTE ucAlphaVal, bool bFading, BYTE ucFadingOffset, DWORD *uBlendingOut)
{

	DWORD uSrcRed, uSrcGreen, uSrcBlue;
	DWORD uDstRed, uDstGreen, uDstBlue;
	DWORD uBldRed, uBldGreen, uBldBlue;	
	
	uSrcRed= (uSrcData & 0x00ff0000)>>16;  // Mask R
	uSrcGreen = (uSrcData & 0x0000ff00)>>8;	 // Mask G
	uSrcBlue = uSrcData & 0x000000ff;		 // Mask B

	uDstRed = (uDstData & 0x00ff0000)>>16; // Mask R
	uDstGreen = (uDstData & 0x0000ff00)>>8;  // Mask G
	uDstBlue = uDstData & 0x000000ff;		 // Mask B

	if(bFading) {
		uBldRed= ((uSrcRed*(ucAlphaVal+1))>>8) + ucFadingOffset; // R output
		uBldGreen= ((uSrcGreen*(ucAlphaVal+1))>>8) + ucFadingOffset; // G output
		uBldBlue= ((uSrcBlue*(ucAlphaVal+1)>>8)) + ucFadingOffset; // B output
		if(uBldRed>=256) uBldRed=255;
		if(uBldGreen>=256) uBldGreen=255;
		if(uBldBlue>=256) uBldBlue=255;
	}
	else {
		uBldRed= ((uSrcRed*(ucAlphaVal+1)) + (uDstRed*(256-ucAlphaVal)))>>8; // R output
		uBldGreen= ((uSrcGreen*(ucAlphaVal+1)) + (uDstGreen*(256-ucAlphaVal)))>>8; // G output
		uBldBlue= ((uSrcBlue*(ucAlphaVal+1)) + (uDstBlue*(256-ucAlphaVal)))>>8; // B output
	}

	*uBlendingOut = (uBldRed<<16) | (uBldGreen<<8) | uBldBlue;
}


void FIMGSE2D::Convert24bpp(DWORD uSrcData, CSPACE eBpp, bool bSwap, DWORD *uConvertedData)
{

	DWORD uRed, uGreen, uBlue;
	
	switch(eBpp) {
		case  ARGB8: // 15 bit color mode
			if(bSwap == 1) {  // pde_state == 2(BitBlt)
				uRed = uSrcData & 0x00007c00;  // R
				uGreen = uSrcData & 0x000003e0;  // G
				uBlue = uSrcData & 0x0000001f;  // B
			
				*uConvertedData = uRed<<9 | uGreen<<6 | uBlue<<3; // SUM
			}
			else { //hsel = 0
				uRed = uSrcData & 0x7c000000;
				uGreen = uSrcData & 0x03e00000;
				uBlue = uSrcData & 0x001f0000;

				*uConvertedData = uRed>>7 | uGreen>>10 | uBlue>>13;
			} 
			break;
		case RGB16 : // 16 bit color mode
			if(bSwap == 1) {
				uRed = uSrcData & 0x0000f800;
				uGreen = uSrcData & 0x000007e0;
				uBlue = uSrcData & 0x0000001f;

				*uConvertedData = uRed<<8 | uGreen<<5 | uBlue<<3;
			}
			else {
				uRed = uSrcData & 0xf8000000;
				uGreen = uSrcData & 0x07e00000;
				uBlue = uSrcData & 0x001f0000;

				*uConvertedData = uRed>>8 | uGreen>>11 | uBlue>>13;
			}
			break;	

		case RGB18 : // 18 bit color mode
			uRed = uSrcData & 0x0003f000;
			uGreen = uSrcData & 0x00000fc0;
			uBlue = uSrcData & 0x0000003f;
	
			*uConvertedData = uRed<<6 | uGreen<<4 | uBlue<<2;
			break;

		case RGB24 : // 24 bit color mode
			*uConvertedData = uSrcData;
			break;
	} // End of switch
} // End of g2d_cvt24bpp function


void FIMGSE2D::GetRotateCoordinate(DWORD uDstX, DWORD uDstY, DWORD uOrgX, DWORD uOrgY, DWORD uRType, DWORD *uRsltX, DWORD *uRsltY) 
{

	switch(uRType) {
		case  1 : // No Rotate. bypass.
			*uRsltX = uDstX;
			*uRsltY = uDstY;
			break;
		case  2 : // 90 degree Rotation
			*uRsltX = uOrgX + uOrgY - uDstY;
			*uRsltY = uDstX - uOrgX + uOrgY;			
			break;
		case  4 : // 180 degree Rotation
			*uRsltX = 2*uOrgX - uDstX;
			*uRsltY = 2*uOrgY - uDstY;
			break;
		case  8 : // 270 degree Rotation
			*uRsltX = uDstY + uOrgX - uOrgY;
			*uRsltY = uOrgX + uOrgY - uDstX;
			break;
		case 16 : // X-flip
			*uRsltX = uDstX;
			*uRsltY = 2*uOrgY - uDstY;
			break;
		case 32 : // Y-flip
			*uRsltX = 2*uOrgX - uDstX;
			*uRsltY = uDstY;		
			break;
		default :
			Assert(0);
			break;
	}
}

void FIMGSE2D::IntEnableForDeEngineFinish(void)
{
	uIntCnt=0; bG2dDone=0;
	m_pG2DReg->INTEN = (m_pG2DReg->INTEN)&~(0x7<<8) | (1<<10);
	m_pG2DReg->INTC_PEND = (0x80000000|(7<<8));
	m_pG2DReg->INTC_PEND = 0x80000000;
}
void FIMGSE2D::IntEnableForCmdFinish(void)
{
	uIntCnt=0; bG2dDone=0;
	m_pG2DReg->INTEN = ((m_pG2DReg->INTEN)&~(0x7<<8)) | (1<<9);
	m_pG2DReg->INTC_PEND = 0x80000000;
}
void FIMGSE2D::IntEnableForOverflow(bool bFifo, BYTE ucFifoLevel)
{
	uIntCnt=0;
	if(bFifo) {
//		m_pG2DReg->INTEN = ((m_pG2DReg->INTEN)&~(0x7<<8))|(1<<8)|1;
		m_pG2DReg->INTEN = ((m_pG2DReg->INTEN)&~(0x7<<8))|1;
		m_pG2DReg->FIFO_INTC = ucFifoLevel;
	}	
	else
		m_pG2DReg->INTEN = ((m_pG2DReg->INTEN)&~(0x7<<8))|(1<<8);
	m_pG2DReg->INTC_PEND = 0x80000000;
}
void FIMGSE2D::InterruptDisAll(void)
{
//	printf("The total number of interrupts occured:[Expected:%d], [Real:%d]\n",  (m_uMaxDx+1)*(m_uMaxDy+1),uIntCnt);
	uIntCnt=0;
	m_pG2DReg->INTEN = (m_pG2DReg->INTEN)&~((3<<8)|1);
	
}

BOOL FIMGSE2D::InitializeInterrupt(void)
{
	DWORD dwIRQ;

	dwIRQ = IRQ_2D;					// 2D Accelerator IRQ
	m_dwSysIntr2D = SYSINTR_UNDEFINED;
	m_hInterrupt2D = NULL;

	if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &dwIRQ, sizeof(DWORD), &m_dwSysIntr2D, sizeof(DWORD), NULL))
	{
		m_dwSysIntr2D = SYSINTR_UNDEFINED;
		return FALSE;
	}

	m_hInterrupt2D = CreateEvent(NULL, FALSE, FALSE, NULL);
	if(NULL == m_hInterrupt2D)
	{
		return FALSE;
	}

	if (!(InterruptInitialize(m_dwSysIntr2D, m_hInterrupt2D, 0, 0)))
	{
		return FALSE;
	}	
	return TRUE;
}

void FIMGSE2D::DeinitInterrupt(void)
{
	if (m_dwSysIntr2D != SYSINTR_UNDEFINED)
	{
		InterruptDisable(m_dwSysIntr2D);
	}

	if (m_hInterrupt2D != NULL)
	{
		CloseHandle(m_hInterrupt2D);
	}

	if (m_dwSysIntr2D != SYSINTR_UNDEFINED)
	{
		KernelIoControl(IOCTL_HAL_RELEASE_SYSINTR, &m_dwSysIntr2D, sizeof(DWORD), NULL, 0, NULL);
	}	
}