📄 g2d.c
字号:
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_SetCoordinateDstBlock(u32 uStartX, u32 uStartY, u32 uEndX, u32 uEndY)
{
G2D_CheckFifo(17);
Outp32(rG2D_COORD2_X, uStartX);
Outp32(rG2D_COORD2_Y, uStartY);
Outp32(rG2D_COORD3_X, uEndX);
Outp32(rG2D_COORD3_Y, uEndY);
}
void G2D_SetFirstBitBLTData(u32 uFirstData)
{
G2D_CheckFifo(17);
Outp32(rG2D_CMDR2, uFirstData);
}
void G2D_SetNextBitBLTData(u32 uNextData)
{
G2D_CheckFifo(17);
Outp32(rG2D_CMDR3, uNextData);
}
void G2D_SetStencilKey(u32 uIsColorKeyOn, u32 uIsInverseOn, u32 uIsSwapOn)
{
Outp32(rG2D_COLORKEY_CNTL, ((uIsColorKeyOn&1)<<31)|((uIsInverseOn&1)<<23)|(uIsSwapOn&1));
}
void G2D_SetStencilMinMax(u32 uRedMin, u32 uRedMax, u32 uGreenMin, u32 uGreenMax, u32 uBlueMin, u32 uBlueMax)
{
Outp32(rG2D_COLORKEY_DR_MIN, ((uRedMin&0xff)<<16)|((uGreenMin&0xff)<<8)|(uBlueMin&0xff));
Outp32(rG2D_COLORKEY_DR_MAX, ((0xffU<<24)|(uRedMax&0xff)<<16)|((uGreenMax&0xff)<<8)|(uBlueMax&0xff));
}
void G2D_GetFrmSz(u32 *uG2dWidth, u32 *uG2dHeight)
{
u32 uMaxScreenVal;
uMaxScreenVal=Inp32(rG2D_SC_WINDOW);
*uG2dWidth = (uMaxScreenVal&0x7ff)+1;
*uG2dHeight = ((uMaxScreenVal>>16)&0x7ff)+1;
}
void G2D_GetFbAddr(u32 *uG2dFbAddr)
{
*uG2dFbAddr= Inp32(rG2D_FB_BA);
}
void G2D_GetBppMode(CSPACE *eBpp)
{
u32 uBppVal;
uBppVal=Inp32(rG2D_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 G2D_SetColorExpansionMethod(bool bIsScr2Scr)
{
oG2d.m_bIsScr2Scr = (bIsScr2Scr) ? 1 : 0;
}
void G2D_SetFontAddr(u32 uFontAddr)
{
oG2d.m_uFontAddr= uFontAddr;
}
void G2D_InterruptEnable(void)
{
Outp32(rG2D_INTEN, 0x1<<9);//Enable Interrupt
Outp32(rG2D_INT_PEND_REG, 0x80000000);
bG2dDone=0;
}
void G2D_InterruptDisable(void)
{
Outp32(rG2D_INTEN, (Inp32(rG2D_INTEN)&~(1<<9)));//Enable Interrupt
}
void __irq Isr_G2d(void)
{
bG2dDone=1;
Outp32(rG2D_INT_PEND_REG, ((1<<31)|(1<<9)));
Outp32(rG2D_INT_PEND_REG, (u32)(1<<31)); // Victor gave us a guidance such this line to clear pending.
// printf("done\n");
INTC_ClearVectAddr();
}
void __irq Isr_G2dProfile(void)
{
#ifdef PROFILE
volatile u32 uSpendTime;
uSpendTime=StopTimer(0);
printf("%6f %10.6f\n", (float)(uSpendTime/1000000.), (float)(1/(uSpendTime/1000000.)));
#endif
bG2dDone=1;
Outp32(rG2D_INT_PEND_REG, ((1<<31)|(1<<9)));
Outp32(rG2D_INT_PEND_REG, (u32)(1<<31)); // Victor gave us a guidance such this line to clear pending.
// printf("done\n");
INTC_ClearVectAddr();
}
void G2D_SetEndian(bool bEndian)
{
Outp32(rG2D_ENDIAN_READSIZE, (Inp32(rG2D_ENDIAN_READSIZE) & ~(1<<4))|(bEndian<<4));
}
void G2d_SetReadSize(u8 ucReadSize)
{
Outp32(rG2D_ENDIAN_READSIZE, (Inp32(rG2D_ENDIAN_READSIZE) & ~(3))|ucReadSize);
}
void G2D_DrawImage(CSPACE eBpp)
{
u32 i,j,k;
if(eBpp==RGB16) {
k=0;
for(j=0; j<240; j++)
for(i=0; i<320; i++)
G2D_PutPixel(i, j, sun320240_16bpp[k++]);
}
else if(eBpp==RGB24) {
k=0;
for(j=0; j<240; j++)
for(i=0; i<320; i++)
G2D_PutPixel(i, j, sun320240_24bpp[k++]);
} else;
}
void G2D_RopOperation(bool bSrcData, bool bDstData, bool bThirdData, u8 ucRopVal, bool *bOut)
{
if((bSrcData==0) && (bDstData==0) && (bThirdData ==0)) *bOut=(bool)((ucRopVal>>0)&0x1);
else if((bSrcData==0 )&& (bDstData==0) && (bThirdData ==1)) *bOut=(bool)((ucRopVal>>1)&0x1);
else if((bSrcData==0) && (bDstData==1) && (bThirdData ==0)) *bOut=(bool)((ucRopVal>>2)&0x1);
else if((bSrcData==0) && (bDstData==1) && (bThirdData ==1)) *bOut=(bool)((ucRopVal>>3)&0x1);
else if((bSrcData==1) && (bDstData==0) && (bThirdData ==0)) *bOut=(bool)((ucRopVal>>4)&0x1);
else if((bSrcData==1) && (bDstData==0) && (bThirdData ==1)) *bOut=(bool)((ucRopVal>>5)&0x1);
else if((bSrcData==1) && (bDstData==1) && (bThirdData ==0)) *bOut=(bool)((ucRopVal>>6)&0x1);
else if((bSrcData==1) && (bDstData==1) && (bThirdData ==1)) *bOut=(bool)((ucRopVal>>7)&0x1);
else Assert(0);
}
void G2D_RopOut(u32 uSrcData, u32 uDstData, u32 uThirdData, u8 ucRopVal, CSPACE eBpp, u32 *uRopOut)
{
u32 i;
u32 uDataMask;
u32 uDataSize;
bool bSrcData, bDstData, bThirdData, bOutData;
if(eBpp==RGB16) {
uDataMask=0xffff;
uDataSize=16;
}
else if(eBpp==RGB18) {
uDataMask=0x3ffff;
uDataSize=18;
}
else if(eBpp==RGB24) {
uDataMask=0xffffff;
uDataSize=24;
}
else Assert(0);
*uRopOut = 0;
for(i=0; i<uDataSize; i++) {
bSrcData=(bool)(((uSrcData&uDataMask)>>i)&1);
bDstData=(bool)(((uDstData&uDataMask)>>i)&1);
bThirdData=(bool)(((uThirdData&uDataMask)>>i)&1);
G2D_RopOperation(bSrcData, bDstData, bThirdData, ucRopVal, &bOutData);
*uRopOut |= (bOutData << i);
}
}
void G2D_ConvertEcolorToRaw(G2D_COLOR eColor, u32 *uRawColor)
{
*uRawColor=oG2d.m_uColorVal[eColor];
}
void G2D_GetFbData(u32 uX, u32 uY, u32 uG2dWidth, u32 uG2dFbAddr, CSPACE eBpp, u32 *uFbData)
{
if(eBpp==RGB24 || eBpp==RGB18)
*uFbData=Inp32(uG2dFbAddr+(uY*uG2dWidth+uX)*4);
else
*uFbData=Inp16(uG2dFbAddr+(uY*uG2dWidth+uX)*2);
}
void G2D_SetFbData(u32 uX, u32 uY, u32 uG2dWidth, u32 uG2dFbAddr, CSPACE eBpp, u32 uFbData)
{
if(eBpp==RGB24 || eBpp==RGB18)
Outp32(uG2dFbAddr+(uY*uG2dWidth+uX)*4, uFbData);
else
Outp16(uG2dFbAddr+(uY*uG2dWidth+uX)*2, uFbData);
}
void G2D_GetPatternOffset(u8 *ucPatOffsetX, u8 *ucPatOffsetY)
{
*ucPatOffsetX=Inp32(rG2D_PAT_OFF_X);
*ucPatOffsetY=Inp32(rG2D_PAT_OFF_Y);
}
void G2D_ConvertPatternToRaw(u16 uThirdDataOrg, CSPACE eBpp, u32 *uThirdDataConverted)
{
u32 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 G2D_BlendingOut(u32 uSrcData, u32 uDstData, u8 ucAlphaVal, bool bFading, u8 ucFadingOffset, u32 *uBlendingOut)
{
u32 uSrcRed, uSrcGreen, uSrcBlue;
u32 uDstRed, uDstGreen, uDstBlue;
u32 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 G2d_Convert24bpp(u32 uSrcData, CSPACE eBpp, bool bSwap, u32 *uConvertedData)
{
u32 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 G2D_GetRotateCoordinate(u32 uDstX, u32 uDstY, u32 uOrgX, u32 uOrgY, u32 uRType, u32 *uRsltX, u32 *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;
}
}
// Interrupt TEST!!!!
void G2D_PutPixelForInterrupt(u32 uPosX, u32 uPosY, u32 uColor)
{
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;
// printf("rG2D_INT_PEND_REG:0x%x\n", rG2D_INT_PEND_REG);
}
void G2D_PutPixelForInterruptHard(u32 uG2dWidth, u32 uG2dHeight, u32 uColor)
{
u32 i;
Outp32(rG2D_COORD0_X, 0);
Outp32(rG2D_COORD0_Y, 0);
Outp32(rG2D_FG_COLOR, uColor);
for(i=0; i<uG2dWidth*uG2dHeight; i++)
Outp32(rG2D_CMDR0, G2D_REND_POINT_BIT);
}
void G2D_IntEnableForDeEngineFinish(void)
{
uIntCnt=0; bG2dDone=0;
Outp32(rG2D_INTEN, (Inp32(rG2D_INTEN)&~(0x7<<8))|(1<<10));
Outp32(rG2D_INT_PEND_REG, (0x80000000|7<<8));
Outp32(rG2D_INT_PEND_REG, 0x80000000);
}
void G2D_IntEnableForCmdFinish(void)
{
uIntCnt=0; bG2dDone=0;
Outp32(rG2D_INTEN, (Inp32(rG2D_INTEN)&~(0x7<<8))|(1<<9));
Outp32(rG2D_INT_PEND_REG, 0x80000000);
}
void G2D_IntEnableForOverflow(bool bFifo, u8 ucFifoLevel)
{
uIntCnt=0;
if(bFifo) {
// Outp32(rG2D_INTEN, (Inp32(rG2D_INTEN)&~(0x7<<8))|(1<<8)|1);
Outp32(rG2D_INTEN, (Inp32(rG2D_INTEN)&~(0x7<<8))|1);
Outp32(rG2D_FIFO_INT_CON, ucFifoLevel);
}
else
Outp32(rG2D_INTEN, (Inp32(rG2D_INTEN)&~(0x7<<8))|(1<<8));
Outp32(rG2D_INT_PEND_REG, 0x80000000);
}
void G2D_InterruptDisAll(void)
{
printf("The total number of interrupts occured:[Expected:%d], [Real:%d]\n", (oG2d.m_uMaxDx+1)*(oG2d.m_uMaxDy+1),uIntCnt);
uIntCnt=0;
Outp32(rG2D_INTEN, Inp32(rG2D_INTEN)&~((3<<8)|1));
}
void __irq Isr_G2dInt(void)
{
volatile unsigned uPendVal;
bG2dDone=1;
uIntCnt++;
uPendVal=Inp32(rG2D_INT_PEND_REG);
// printf("0x%x\n", uPendVal);
switch((uPendVal>>8)&0x7) {
case 1:
// printf("OV\n");
Outp32(rG2D_INT_PEND_REG, ((1<<31)|(1<<8)));
break;
case 2:
// printf("CMD\n");
Outp32(rG2D_INT_PEND_REG, ((1<<31)|(1<<9)));
break;
case 4:
// printf("DE\n");
Outp32(rG2D_INT_PEND_REG, ((1<<31)|(1<<10)));
break;
default:
// printf("%x\n", uPendVal);
Outp32(rG2D_INT_PEND_REG, ((1<<31)|(0x7<<8)));
break;
}
Outp32(rG2D_INT_PEND_REG, (u32)(1<<31)); // Victor gave us a guidance such this line to clear pending.
INTC_ClearVectAddr();
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -