rotator.c

s3c6400 ADS下官方测试程序

			Outp32(rROTATOR_SRCADDRREG1, 0);
			Outp32(rROTATOR_SRCADDRREG2, 0);
			oROTATOR.m_uSrcAddr1=0;
			oROTATOR.m_uSrcAddr2=0;			
			break; 
		case RGB16:
			Outp32(rROTATOR_SRCADDRREG1, 0);
			Outp32(rROTATOR_SRCADDRREG2, 0);
			oROTATOR.m_uSrcAddr1=0;
			oROTATOR.m_uSrcAddr2=0;
			break;
		case RGB24:
			Outp32(rROTATOR_SRCADDRREG1, 0);
			Outp32(rROTATOR_SRCADDRREG2, 0);
			oROTATOR.m_uSrcAddr1=0;
			oROTATOR.m_uSrcAddr2=0;
			break;
		default:
			Assert(0);
			break;
	}
	
}

void ROTATOR_SetDstAddr(CSPACE eBpp, u32 uFbAddr, u16 usHorSize, u16 usVerSize)
{
	u32 uOffset;

	Outp32(rROTATOR_DESTADDRREG0, uFbAddr);
	oROTATOR.m_uDstAddr0=uFbAddr;
	uOffset=usHorSize*usVerSize;
	switch(eBpp) {
		case YC420:
			Outp32(rROTATOR_DESTADDRREG1, uFbAddr+uOffset);
			Outp32(rROTATOR_SRCADDRREG2, uFbAddr+uOffset+uOffset/4);
			oROTATOR.m_uDstAddr1=uFbAddr+uOffset;
			oROTATOR.m_uDstAddr2=uFbAddr+uOffset+uOffset/4;
			break;
		case YCRYCB:	
		case YCBYCR:
		case CBYCRY:	
			Outp32(rROTATOR_DESTADDRREG1, 0);
			Outp32(rROTATOR_DESTADDRREG2, 0);
			oROTATOR.m_uDstAddr1=0;
			oROTATOR.m_uDstAddr2=0;
			break; 
		case RGB16:
			Outp32(rROTATOR_DESTADDRREG1, 0);
			Outp32(rROTATOR_DESTADDRREG2, 0);
			oROTATOR.m_uDstAddr1=0;
			oROTATOR.m_uDstAddr2=0;
			break;
		case RGB24:
			Outp32(rROTATOR_DESTADDRREG1, 0);
			Outp32(rROTATOR_DESTADDRREG2, 0);
			oROTATOR.m_uDstAddr1=0;
			oROTATOR.m_uDstAddr2=0;
			break;
		default:
			Assert(0);
			break;
	}	
}

void ROTATOR_SetSrcSize(u16 usHorSize, u16 usVerSize)
{
	Outp32(rROTATOR_SRCSIZEREG, (usVerSize<<16)|usHorSize);
	oROTATOR.m_usHorSize=usHorSize;
	oROTATOR.m_usVerSize=usVerSize;	
}

void ROTATOR_SetInFormat(CSPACE eBpp)
{
	u16 usInFormat;

	usInFormat=	(eBpp==YC420) ? ROTATOR_BIT_IN_YC420 :
				(eBpp==YCBYCR || eBpp==CBYCRY || eBpp==YCRYCB) ? ROTATOR_BIT_IN_YC422 :
				(eBpp==RGB16) ? ROTATOR_BIT_IN_RGB565 :
				(eBpp==RGB24) ? ROTATOR_BIT_IN_RGB888 : ROTATOR_BIT_IN_RGB565;
	Outp32(rROTATOR_CTRLCFG, (Inp32(rROTATOR_CTRLCFG)&~(0x7<<13))|usInFormat);		
	oROTATOR.m_usInFormat=usInFormat;
}

void ROTATOR_SetRotType(ROTATOR_ROT_TYPE eRotType)
{
	u8 ucRotType;

	ucRotType=	(eRotType==ROTATOR_TYPE_NONE) ? ROTATOR_BIT_NONE :
				(eRotType==ROTATOR_TYPE_FLIP_VER) ? ROTATOR_BIT_FLIP_VER:
				(eRotType==ROTATOR_TYPE_FLIP_HOR) ? ROTATOR_BIT_FLIP_HOR :
				(eRotType==ROTATOR_TYPE_ROT_90) ? ROTATOR_BIT_ROT_90 :
				(eRotType==ROTATOR_TYPE_ROT_180) ? ROTATOR_BIT_ROT_180 :
				(eRotType==ROTATOR_TYPE_ROT_270) ? ROTATOR_BIT_ROT_270 : ROTATOR_BIT_NONE;
	Outp32(rROTATOR_CTRLCFG, (Inp32(rROTATOR_CTRLCFG)&~(0xf<<4))|ucRotType);	
	oROTATOR.m_ucRotType=ucRotType;	
}



void ROTATOR_Start(void)
{
	Outp32(rROTATOR_CTRLCFG, Inp32(rROTATOR_CTRLCFG)|(ROTATOR_BIT_START));
//	while((Inp32(rROTATOR_CTRLCFG)&ROTATOR_BIT_START)); // This line should be disabled when One More Job is enabled.
}

void ROTATOR_CheckDone(void)
{
	u32 uSTATCFG;
#if 0 
	while(!(Inp32(rROTATOR_STATCFG)&(1<<8)));

#else // Checking the behavior of pending bit
	do	{
		uSTATCFG=Inp32(rROTATOR_STATCFG);
		printf("STATCFG:0x%x\n", uSTATCFG);
	}	
	while(!(uSTATCFG&(1<<8)));
#endif
	printf("ROTATOR is done[0x%x]!\n", Inp32(rROTATOR_STATCFG));
}

void ROTATOR_CheckIdle(void)
{
	while(Inp32(rROTATOR_STATCFG)&0x3);
}

void ROTATOR_IntEnable(void)
{
	bRotatorDone=0;
	oROTATOR.m_bIntEn=true;
	Inp32(rROTATOR_STATCFG);
	Outp32(rROTATOR_CTRLCFG, Inp32(rROTATOR_CTRLCFG)|ROTATOR_BIT_INT_EN);
}

void ROTATOR_IntDisable(void)
{
	bRotatorDone=0;
	oROTATOR.m_bIntEn=false;
	Inp32(rROTATOR_STATCFG);
	Outp32(rROTATOR_CTRLCFG, (Inp32(rROTATOR_CTRLCFG)&~(ROTATOR_BIT_INT_EN)));
}

void __irq Isr_Rotator(void)
{
	//u32 uSTATCFG;
	
	bRotatorDone=1;
#if 1 
	Inp32(rROTATOR_STATCFG);
	
#else // Checking the behavior of pending bit
		do	{
			uSTATCFG=Inp32(rROTATOR_STATCFG);
			printf("STATCFG:0x%x\n", uSTATCFG);
		}	
		while(!(uSTATCFG&(1<<8)));
#endif
//	printf("Rotator Done Interrupt is occured[0x%x]!\n", Inp32(rROTATOR_STATCFG));
	INTC_ClearVectAddr();
}

void __irq Isr_RotatorOneMoreJob(void)
{
	//u32 uSTATCFG;
	
	bRotatorDone=1;
#if 1 
	Inp32(rROTATOR_STATCFG);
	
#else // Checking the behavior of pending bit
		do	{
			uSTATCFG=Inp32(rROTATOR_STATCFG);
			printf("STATCFG:0x%x\n", uSTATCFG);
		}	
		while(!(uSTATCFG&(1<<8)));
#endif
	printf("Rotator Done Interrupt!\n");
//	printf("Rotator Done Interrupt is occured[0x%x]!\n", Inp32(rROTATOR_STATCFG));
	INTC_ClearVectAddr();
}

void ROTATOR_CheckIntDone(void)
{
	while(!bRotatorDone);
	bRotatorDone=0;
}



void ROTATOR_InitRegs(void)
{
	Outp32(rROTATOR_CTRLCFG, (oROTATOR.m_bIntEn<<24)|oROTATOR.m_usInFormat|oROTATOR.m_ucRotType|oROTATOR.m_bStartRot);
	Outp32(rROTATOR_SRCADDRREG0, oROTATOR.m_uSrcAddr0);
	Outp32(rROTATOR_SRCADDRREG1, oROTATOR.m_uSrcAddr1);
	Outp32(rROTATOR_SRCADDRREG2, oROTATOR.m_uSrcAddr2);
	Outp32(rROTATOR_SRCSIZEREG, (oROTATOR.m_usVerSize<<16)|oROTATOR.m_usHorSize);
	Outp32(rROTATOR_DESTADDRREG0, oROTATOR.m_uDstAddr0);
	Outp32(rROTATOR_DESTADDRREG1, oROTATOR.m_uDstAddr1);
	Outp32(rROTATOR_DESTADDRREG2, oROTATOR.m_uDstAddr2);	
}



void ROTATOR_InitSetting(CSPACE eBgBpp, u16 usHorSize, u16 usVerSize, u32 uRotSrcAddr, u32 uRotDstAddr, ROTATOR_ROT_TYPE eRotType)
{

	u32 uOffset;

	if(oROTATOR.m_bRotInit) {
		oROTATOR.m_bIntEn=false;
		oROTATOR.m_bStartRot=false;
	}
	oROTATOR.m_ucRotType=	(eRotType==ROTATOR_TYPE_NONE) ? ROTATOR_BIT_NONE :
							(eRotType==ROTATOR_TYPE_FLIP_VER) ? ROTATOR_BIT_FLIP_VER:
							(eRotType==ROTATOR_TYPE_FLIP_HOR) ? ROTATOR_BIT_FLIP_HOR :
							(eRotType==ROTATOR_TYPE_ROT_90) ? ROTATOR_BIT_ROT_90 :
							(eRotType==ROTATOR_TYPE_ROT_180) ? ROTATOR_BIT_ROT_180 :
							(eRotType==ROTATOR_TYPE_ROT_270) ? ROTATOR_BIT_ROT_270 : ROTATOR_BIT_NONE;
	oROTATOR.m_usHorSize=usHorSize;
	oROTATOR.m_usVerSize=usVerSize;

	oROTATOR.m_uSrcAddr0=uRotSrcAddr;	
	oROTATOR.m_uDstAddr0=uRotDstAddr;
	
	uOffset=usHorSize*usVerSize;
	switch(eBgBpp) {
		case YC420:
			oROTATOR.m_usInFormat=ROTATOR_BIT_IN_YC420;
			oROTATOR.m_uSrcAddr1=oROTATOR.m_uSrcAddr0+uOffset;
			oROTATOR.m_uSrcAddr2=oROTATOR.m_uSrcAddr1+uOffset/4;
			oROTATOR.m_uDstAddr1=oROTATOR.m_uDstAddr0+uOffset; 
			oROTATOR.m_uDstAddr2=oROTATOR.m_uDstAddr1+uOffset/4; 
			break;
		case YCRYCB:	
		case YCBYCR:
		case CBYCRY:	
			oROTATOR.m_usInFormat=ROTATOR_BIT_IN_YC422;
			oROTATOR.m_uSrcAddr1=0;
			oROTATOR.m_uSrcAddr2=0;
			oROTATOR.m_uDstAddr1=0;	
			oROTATOR.m_uDstAddr2=0;				
			break; 
		case RGB16:
			oROTATOR.m_usInFormat=ROTATOR_BIT_IN_RGB565;
			oROTATOR.m_uSrcAddr1=0;
			oROTATOR.m_uSrcAddr2=0;
			oROTATOR.m_uDstAddr1=0; 
			oROTATOR.m_uDstAddr2=0; 
			break;
		case RGB24:
			oROTATOR.m_usInFormat=ROTATOR_BIT_IN_RGB888;
			oROTATOR.m_uSrcAddr1=0;
			oROTATOR.m_uSrcAddr2=0;
			oROTATOR.m_uDstAddr1=0; 
			oROTATOR.m_uDstAddr2=0; 
			break;
		default:
			Assert(0);
			break;
	}

	ROTATOR_InitRegs();

}

void ROTATOR_InitLcd(LCD_WINDOW eWin, CSPACE eBpp)
{
	u32 uLcdFbAddr;
	u32 uLcdWidth, uLcdHeight, uLcdOffsetX, uLcdOffsetY;


	if(eWin==WIN0) {
		uLcdFbAddr=oROTATOR.m_uLcdFbAddr0;
		uLcdHeight=oROTATOR.m_uLcdHeight0;
		uLcdWidth=oROTATOR.m_uLcdWidth0;
		uLcdOffsetX=oROTATOR.m_uLcdOffsetX0;
		uLcdOffsetY=oROTATOR.m_uLcdOffsetY0;		
	}	
	else if(eWin==WIN1) {
		uLcdFbAddr=oROTATOR.m_uLcdFbAddr1;
		uLcdHeight=oROTATOR.m_uLcdHeight1;
		uLcdWidth=oROTATOR.m_uLcdWidth1;
		uLcdOffsetX=oROTATOR.m_uLcdOffsetX1;
		uLcdOffsetY=oROTATOR.m_uLcdOffsetY1;		
	}
	else Assert(0);

	LCD_SetPort();
	LCD_InitLDI(MAIN);
	LCD_InitBase();
	LCD_InitWin(eBpp, uLcdWidth, uLcdHeight, 0, 0, uLcdWidth, uLcdHeight, uLcdOffsetX, uLcdOffsetY, uLcdFbAddr, eWin, 0);	
	LCD_SetWinOnOff(1, eWin);

}

void ROTATOR_Init(u8 ucTestMode)
{

	u32 uLcdWidth0, uLcdHeight0, uLcdWidth1, uLcdHeight1;
	CSPACE eBgBpp;
	LCD_WINDOW eBgWin0, eBgWin1;
	u32 uLcdFbAddr0, uLcdFbAddr1;
	u32 uRotSrcAddr;
	u16 usRotWidth, usRotHeight;
	u32 uOffsetX, uOffsetY;


	eBgWin0=WIN0;
	eBgWin1=WIN1;
	eBgBpp=RGB16;


	uLcdFbAddr0  = _DRAM_BaseAddress+0x04000000;
	uLcdFbAddr1  = _DRAM_BaseAddress+0x04800000;
	uRotSrcAddr = _DRAM_BaseAddress+0x05000000;

	oROTATOR.m_uLcdFbAddr0=uLcdFbAddr0;
	oROTATOR.m_uLcdFbAddr1=uLcdFbAddr1;


	#if (LCD_MODULE_TYPE== LTV350QV_RGB)
		printf("Selected LCD Module Type: LTV350QV_RGB\n");
		uLcdWidth0=320;
		uLcdHeight0=240;
		uLcdWidth1=uLcdHeight1=240;
		uOffsetX=(320-240)/2;
		uOffsetY=0;
		oROTATOR.m_uLcdOffsetX1=uOffsetX;
		oROTATOR.m_uLcdOffsetY1=uOffsetY;	
	#elif (LCD_MODULE_TYPE == LTS222QV_CPU)
		printf("Selected LCD Module Type: LTS222QV_CPU\n");
		uLcdWidth0=240;
		uLcdHeight0=320;	
		uLcdWidth1=uLcdHeight1=240;
		uOffsetX=0;
		uOffsetY=(320-240)/2;
		oROTATOR.m_uLcdOffsetX1=uOffsetX;
		oROTATOR.m_uLcdOffsetY1=uOffsetY;	
	#elif (LCD_MODULE_TYPE == LTE480WV_RGB)
		printf("Selected LCD Module Type: LTE480WV_RGB\n");
		uLcdWidth0=800;
		uLcdHeight0=480;	
		uLcdWidth1=uLcdHeight1=800;
		uOffsetX=0;
		uOffsetY=(800-480)/2;
		oROTATOR.m_uLcdOffsetX1=uOffsetX;
		oROTATOR.m_uLcdOffsetY1=uOffsetY;	
	#elif (LCD_MODULE_TYPE == LTP700WV_RGB)
		printf("Selected LCD Module Type: LTP700WV_RGB\n");
		uLcdWidth0=800;
		uLcdHeight0=480;	
		uLcdWidth1=uLcdHeight1=800;
		uOffsetX=0;
		uOffsetY=(800-480)/2;
		oROTATOR.m_uLcdOffsetX1=uOffsetX;
		oROTATOR.m_uLcdOffsetY1=uOffsetY;
	#else
		Assert(0);
	#endif
	oROTATOR.m_uLcdWidth0=uLcdWidth0;
	oROTATOR.m_uLcdWidth1=uLcdWidth1;
	oROTATOR.m_uLcdHeight0=uLcdHeight0;
	oROTATOR.m_uLcdHeight1=uLcdHeight1;
	oROTATOR.m_uLcdOffsetX0=0;
	oROTATOR.m_uLcdOffsetY0=0;

	POST_InitCh(POST_A, &oPost);
	POST_InitCh(POST_B, &oSc);


	LCD_SetPort();
	LCD_InitLDI(MAIN);

	LCD_SetPort();
	LCD_InitLDI(MAIN);
	LCD_InitBase();
	
	LCD_InitWin(eBgBpp, uLcdWidth0, uLcdHeight0, 0, 0, uLcdWidth0, uLcdHeight0, 0, 0, uLcdFbAddr0, eBgWin0, false);
	LCD_SetWinOnOff(1, eBgWin0);
	GLIB_InitInstance(uLcdFbAddr0, uLcdWidth0, uLcdHeight0, eBgBpp);
	GLIB_DrawPattern(uLcdWidth0, uLcdHeight0);
	usRotWidth=(u16)uLcdHeight0;
	usRotHeight=(u16)uLcdWidth0;

	if(ucTestMode==DOUBLE_WINDOW) {
		LCD_InitWin(eBgBpp, uLcdWidth1, uLcdHeight1, 0, 0, uLcdWidth1, uLcdHeight1, uOffsetX, uOffsetY, uLcdFbAddr1, eBgWin1, false);
		LCD_SetWinOnOff(1, eBgWin1);	
		GLIB_InitInstance(uLcdFbAddr1, uLcdWidth1, uLcdHeight1, eBgBpp);
		GLIB_DrawPattern2(uLcdWidth1, uLcdHeight1);
		usRotWidth=(u16)uLcdHeight1;
		usRotHeight=(u16)uLcdWidth1;
	}
//	GLIB_PutLine(0, 0, 0, uLcdHeight0-1, C_BLUE);
	
	LCD_Start();

	GLIB_InitInstance(uRotSrcAddr, usRotWidth, usRotHeight, eBgBpp);
	oROTATOR.m_bRotInit=true;
	ROTATOR_InitSetting(eBgBpp, usRotWidth, usRotHeight, uRotSrcAddr, uLcdFbAddr0, ROTATOR_TYPE_ROT_90);
	oROTATOR.m_bRotInit=false;
	
	printf("lcdwidht=%d, lcdheight=%d\n", uLcdWidth0, uLcdHeight0);
	printf("rotator width=%d, rotator height=%d\n", usRotWidth, usRotHeight);
}