attr 		= P_PPU_TX1_Attribute 	+ nTextLayer * 7;
	x 			= P_PPU_TX1_X 			+ nTextLayer * 7;
	y 			= P_PPU_TX1_Y 			+ nTextLayer * 7;
	control 	= P_PPU_TX1_Control 	+ nTextLayer * 7;
	
	port 		= pIndexAddr;
	
	for(i=0; i< nYSize; i++)
	{		
		if(nColorMode == TX_Color65536)
			*(port + i) = i* (nXSize * nColorMode / 32);
		else		
			*(port + i) = i* (nXSize * nColorMode / 16);	 
	}		
		
	*index 		= (U32)pIndexAddr;				
	*addr 		= (U32)pPatAddr;	
	*(addr + 1) = (U32)pPatAddr;	
	*(addr + 2) = (U32)pPatAddr;	
	*x 			= 0;
	*y 			= 0;
	*control 	= TXEN|TXLINEAR|TXREGMODE;	
	
	switch(nColorMode)
	{
		case TX_Color4:
		case TX_Color16:
			*attr 	= ((nColorMode>>2) | nDepthLayer | nBank);
			break;
		case TX_Color64:
		case TX_Color256:
			*attr 	= (((nColorMode>>2) + 1) | nDepthLayer | nBank);
			break;
		case TX_Color32768:
			*control|= TXRGB555 ;//| 
			*attr 	= nDepthLayer;				
			break;
		case TX_Color65536:
			*control|= TXRGB565;// | nDepthLayer			
			*attr 	= nDepthLayer;
			break;
	}
}

//PPU_Sprite
/**
 * PPU_InitSprite - initialize sprite.
 */
void PPU_InitSprite(void)
{
	U16	i;
	PAINT_CELL	*pPaintCell;

	//initialize SPRITE_TABLE
	for(i=0; i<SPRITE_NUM_MAX; i++)
	{
		SPRITE_TABLE[i].SprList.prev	= (LISTHEAD*)NULL;
		SPRITE_TABLE[i].SprList.next	= (LISTHEAD*)NULL;
		SPRITE_TABLE[i].nCtrlFlag		= 0x00000000;
		SPRITE_TABLE[i].stPos.x			= 0;
		SPRITE_TABLE[i].stPos.y			= 0;
		SPRITE_TABLE[i].pFrame			= (FRAME*)NULL;
	}

	//initialize SPRITE_FREE_LIST, add all SPTITE into SPRITE_FREE_LIST
	INIT_LIST_HEAD(&SPRITE_FREE_LIST);
	for (i = 0; i < SPRITE_NUM_MAX; i++)
	{
		list_add_tail(&SPRITE_TABLE[i].SprList, &SPRITE_FREE_LIST);
	}

	//initialize SPRITE_PRI_LIST
	for (i = 0; i < SPRITE_PRI_MAX/2; i++)
	{
		INIT_LIST_HEAD(&SPRITE_PRI_LIST[i]);
	}

	{//initialize cell register (pack function in the future)
		pPaintCell = (PAINT_CELL*)(P_PPU_Sprite);
		for(i=0; i<CELL_NUM_MAX; i++)
		{
			pPaintCell->SP_Attribute1.DW	= 0;
			pPaintCell->SP_Attribute2.DW	= 0;
			pPaintCell++;	//add 8 byte
		}
	}
	PPU_SetSP_BUF_SA(SP_PGT_ADDR);	//get the sprite PGT data (Array Data)
	PPU_SetSP_En(SP_ENABLE);
	g_nUsed_Cell_Count		= 0;
	g_bShowSpriteFlag		= false;
}

/**
 * PPU_AllocSprite - alloc sprite.
 * @pFrame:
 * @x:
 * @y:
 * @nPri:
 * @RETURN:
 */
SPRITE* PPU_AllocSprite( const FRAME *pFrame, S16 x, S16 y, U16 nPri )
{
	SPRITE *pSprite;
	LISTHEAD *pList, *pPriList;

#ifdef ARG_CHK_EN
	if (pFrame == (FRAME*)NULL)
	{
		return (SPRITE*)NULL;
	}
#endif

	//Check sprite priority
	if (nPri >= SPRITE_PRI_MAX)
	{
		nPri = SPRITE_PRI_MAX - 1;
	}

	//Check Sprite free list is empty or not
	if (list_empty(&SPRITE_FREE_LIST))
	{
		return (SPRITE*)NULL;
	}

	pList	= SPRITE_FREE_LIST.next;
	pSprite = List2Sprite(pList);
	list_del(pList);					//delete assigned SPRITE from Sprite free list

	//set sprite basic info
	pSprite->stPos.x	= x;
	pSprite->stPos.y	= y;
	pSprite->nCtrlFlag	= 0x00000000;
	pSprite->pFrame		= (FRAME*)pFrame;

	//insert assigned sprite to priority list
	pPriList = &SPRITE_PRI_LIST[(nPri>>1)];
	if( (nPri&0x0001) == 1 )
	{
		list_add(pList, pPriList);		//Add to head, so it will have higher Priority
	}
	else
	{
		list_add_tail(pList, pPriList);	//Add to tail, so it will have lower Priority
	}

	return (pSprite);
}

/**
 * PPU_FreeSprite - free sprite.
 * @pSprite:
 */
void PPU_FreeSprite(SPRITE *pSprite)
{
#ifdef ARG_CHK_EN
    if (pSprite < &SPRITE_TABLE[0]
		|| pSprite >= &SPRITE_TABLE[SPRITE_NUM_MAX]
		|| pSprite->pFrame ==(FRAME*)NULL)
	{
		return;
	}
#endif

	//Remove from Sprite Priority list
	list_del(&pSprite->SprList);

	//Clean SPRITE
	pSprite->SprList.prev	= (LISTHEAD*)NULL;
	pSprite->SprList.next	= (LISTHEAD*)NULL;
	pSprite->nCtrlFlag		= 0x00000000;
	pSprite->stPos.x		= 0;
	pSprite->stPos.y		= 0;
	pSprite->pFrame			= (FRAME*)NULL;

	//Add to Free Sprite List
	list_add(&pSprite->SprList, &SPRITE_FREE_LIST);
}

/**
 * PPU_PaintSprite - set all cell register, paint all sprites.
 */
void PPU_PaintSprite(void)
{
	LISTHEAD	*pos, *pHead;
	PAINT_CELL	*pPaintCell;
	SPRITE		*pSprite;
	FRAME		*pFrame;
	FRAME_CELL	*pFrameCell;
	U16			i, nCellCount;
	S16			sScrX,sScrY;			//screen coordinate

	nCellCount	= 0;
	pPaintCell	= (PAINT_CELL*)(P_PPU_Sprite);

	for (pHead=&SPRITE_PRI_LIST[0]; pHead<=(&SPRITE_PRI_LIST[SPRITE_PRI_MAX/2]-1); pHead++)
	{
		list_for_each_prev(pos, pHead)
		{
			pSprite	= List2Sprite(pos);
			pFrame	= pSprite->pFrame;

#ifdef ARG_CHK_EN
			if( pFrame == (FRAME*)NULL )
			{
				continue;
			}
#endif

			sScrX	= pSprite->stPos.x;			//Sprite's screen X(Sprite's cg relative to Screen left-top corner)
			sScrY	= pSprite->stPos.y;			//Sprite's screen Y(Sprite's cg relative to Screen left-top corner)

			//check sprite overstep screen or not
			if( (sScrX - pFrame->stOrgPos.x + pFrame->stSize.width) < 0 ||
				(sScrX - pFrame->stOrgPos.x) > SCREEN_WIDTH ||
				(sScrY - pFrame->stOrgPos.y + pFrame->stSize.height) < 0 ||
				(sScrY - pFrame->stOrgPos.y) > SCREEN_HEIGHT )
			{
				continue;
			}

			//check paint cell numbers is CELL_NUM_MAX
			if( nCellCount + pFrame->nCellNum >= CELL_NUM_MAX )
			{
				continue;
			}

			//paint sprite
#ifndef SPRITETAB_BIN
			pFrameCell	= (FRAME_CELL*)pFrame->pFrameCellTbl;
#else
			pFrameCell	= (FRAME_CELL*)((U32)pFrame->pFrameCellTbl + SP_TBL_ADDR);
#endif
			
			for( i = 0; i < pFrame->nCellNum; i++ )
			{
				pPaintCell->SP_Attribute1.B.nChNum		= pFrameCell->nPGTIndex;
				pPaintCell->SP_Attribute1.B.sPosX		= pFrameCell->sRefX + sScrX;
#ifndef SPRITETAB_BIN				
				pPaintCell->SP_Attribute2.B.nAttribute	= pFrame->pFrameInfo->W;
#else
				pPaintCell->SP_Attribute2.B.nAttribute	= ((FRAME_INFO*)((U32)pFrame->pFrameInfo + SP_TBL_ADDR))->W;
#endif
				pPaintCell->SP_Attribute2.B.sPosY		= pFrameCell->sRefY + sScrY;

				pFrameCell++;
				pPaintCell++;
				nCellCount++;
			}
		}
	}

	//clear all no painted cell
	for( i = nCellCount; i < g_nUsed_Cell_Count; i++ )
	{
		pPaintCell->SP_Attribute1.DW	= 0;
		pPaintCell->SP_Attribute2.DW	= 0;
		pPaintCell++;
	}
	g_nUsed_Cell_Count = nCellCount;
	g_bShowSpriteFlag = false;
}

//PPU_Effect
/**
 * PPU_SetTxBlendLevel - set texture blend level
 * @nText: which texture blend, like "TEXT1, TEXT2, TEXT3"
 * @nBlendLevel: blend level, 0 ~ 63(63 is absolute transparence)
 */
void PPU_SetTxBlendLevel(U8 nText, U8 nBlendLevel)
{
	switch(nText)
	{
	case TEXT1:
		*P_PPU_TX1_Blending = nBlendLevel;
		break;
	case TEXT2:
		*P_PPU_TX2_Blending = nBlendLevel;
		break;
	case TEXT3:
		*P_PPU_TX3_Blending = nBlendLevel;
		break;
	default:
		break;
	}
}

/**
 * PPU_GetTxBlendLevel - get texture blend level
 * @nText: which texture, like "TEXT1, TEXT2, TEXT3"
 * @RETURN: blend level, if return 0xff, "nText" is set error.
 */
U8 PPU_GetTxBlendLevel(U8 nText)
{
	switch(nText)
	{
	case TEXT1:
		return *P_PPU_TX1_Blending;
	case TEXT2:
		return *P_PPU_TX2_Blending;
	case TEXT3:
		return *P_PPU_TX3_Blending;
	}
	return 0xFF;
}

/**
 * PPU_EnableTxBlend - enable or disable texture blending.
 * @bText1: text1 blend enable(true) or disable(false)
 * @bText2: text2 blend enable(true) or disable(false)
 * @bText3: text3 blend enable(true) or disable(false)
 */
void PPU_EnableTxBlend(bool bText1, bool bText2, bool bText3)
{
	*P_PPU_TX1_Control = ((*P_PPU_TX1_Control) & 0xFEFF) | (bText1<<8);
	*P_PPU_TX2_Control = ((*P_PPU_TX2_Control) & 0xFEFF) | (bText2<<8);
	*P_PPU_TX3_Control = ((*P_PPU_TX3_Control) & 0xFEFF) | (bText3<<8);
}

/**
 * PPU_TxHMovement - set every scan line's horizontal movement value.
 * @nMode: 0 - every scan line have the same value; 1 - have different value.
 * @nStartScanline: from which Scan line to begin
 * @nEndScanline: from which Scan line to end
 * @nCompValue: the same movement value, nMode = 0.
 * @pScanline: scan line movement data table, nMode = 1.
 * @nNumberData: movement data table length.
 */
void PPU_TxHMovement
(
 S16 nMode, 
 S32 nStartScanline,
 S32 nEndScanline,
 S32 nCompValue,
 const S8 *pScanline,
 U16 nNumberData
)
{
	S32 i;
	U32 *port;
    U32 nScanLine;
	
	port = P_PPU_Tx_HOffset_ADR; 
	nScanLine=nEndScanline-nStartScanline;
	
	if(nMode == 0)
	{
		for(i = 0; i<nScanLine; i ++)	
		{
			*(port + nStartScanline + i) =nCompValue;		// write Scanline table data to I/O
		}		
	}
	else
	{
		for(i = 0; i<nScanLine; i ++)	
		{
			*(port + nStartScanline + i) =pScanline[nHMovementCnt+1];		// write Scanline table data to I/O
			nHMovementCnt++;
			if(nHMovementCnt>=nNumberData-1)
			nHMovementCnt=0;
		}
	}
} 

/**
 * PPU_EnTxHMovement - enable or disable texture H movement effect.
 * @bText1: text1 HMovement enable(true) or disable(false)
 * @bText2: text2 HMovement enable(true) or disable(false)
 * @bText3: text3 HMovement enable(true) or disable(false)
 */
void PPU_EnTxHMovement(bool bText1, bool bText2, bool bText3)
{
	*P_PPU_TX1_Control = ((*P_PPU_TX1_Control) & 0xFFEF) | (bText1<<4);
	*P_PPU_TX2_Control = ((*P_PPU_TX2_Control) & 0xFFEF) | (bText2<<4);
	*P_PPU_TX3_Control = ((*P_PPU_TX3_Control) & 0xFFEF) | (bText3<<4);
}

/**
 * PPU_TxVCompress - set some attribute about vertical compression.
 * @nCmpValue: text screen vertical compression/extension value(0 ~ 1023)
 					Double size: 0x10
					Unit gain: 0x20
					Half size: 0x40
 * @nCmpStep: text screen vertical compression/extension step value(-128 ~ 127)
 * @nCmpOffset: text screen vertical compression/extension movement value
 */
void PPU_TxVCompress(U16 nCmpValue, S16 nCmpStep, U16 nCmpOffset)
{
	*P_PPU_VComp_Value = nCmpValue;
	*P_PPU_VComp_Step = nCmpStep;
	*P_PPU_VComp_Offset = nCmpOffset;
}

/**
 * PPU_EnTxVCompress - enable or disable texture V Compression effect.
 * @bText1: text1 V Compression enable(true) or disable(false)
 * @bText2: text2 V Compression enable(true) or disable(false)
 * @bText3: text3 V Compression enable(true) or disable(false)
 */
void PPU_EnTxVCompress(bool bText1, bool bText2, bool bText3)
{
	*P_PPU_TX1_Control = ((*P_PPU_TX1_Control) & 0xFFBF) | (bText1<<6);
	*P_PPU_TX2_Control = ((*P_PPU_TX2_Control) & 0xFFBF) | (bText2<<6);
	*P_PPU_TX3_Control = ((*P_PPU_TX3_Control) & 0xFFBF) | (bText3<<6);
}

/**
 * PPU_TxHCompress - Set Horizontal compression value.
 * @nMode: every scan lines's compression value same(0) or different(1)
 * @nStartLine: start scan line
 * @nEndLine: end scan line
 * @nSingleValue: all scan lines use this compression value
 * @pHCmpValueTbl: compression value table
 
 * **NOTE** the horizontal compression is only available in Text1 
 *			and character mode.
 */
void PPU_TxHCompress(U8 nMode, U16 nStartLine, U16 nEndLine, U16 nSingleValue, U16 *pHCmpValueTbl)
{
	U16 i,j;

	nEndLine = (nEndLine > 512) ? (512) : (nEndLine);

	for(i = nStartLine,j = 0; i < nEndLine; i++, j++)
	{
		if(nMode == 0)
		{
			*(P_PPU_Tx1_HCmp_ADR + i) = nSingleValue;
		}
		else
		{
#ifdef ARG_CHK_EN
			if (NULL == pHCmpValueTbl)
			{
				return;
			}
#endif
			*(P_PPU_Tx1_HCmp_ADR + i) = pHCmpValueTbl[j];
		}
	}
}

/**
 * PPU_EnTxHCompress - enable or disable texture H Compression effect.
 * @bText1: text1 V Compression enable(true) or disable(false)
 
 * **NOTE** the horizontal compression is only available in Text1 
 *			and character mode.
 */
void PPU_EnTxHCompress(bool bText1)
{
	*P_PPU_TX1_Control = ((*P_PPU_TX1_Control) & 0xFFDF) | (bText1<<5);
}


//PPU_Palette
/**
 * PPU_SP_InitPalette - initialize sprite palette.
 * @SPPalAddr: sprite palette data start address
 */
void PPU_SP_InitPalette(U32 *pSPPalAddr)
{
	U32 i;
	for (i = 0; i < 512; i++)
		*(P_SP_COLOR_PALETTE + i)	= *(pSPPalAddr + i);
}

/**
 * PPU_BG_InitPalette - initialize texture palette.
 * @BGPalAddr: texture palette data start address
 */
void PPU_BG_InitPalette(U32 *pBGPalAddr)
{
	U32 i;
	for (i = 0; i < 1024; i++)
		*(P_BG_COLOR_PALETTE + i)	= *(pBGPalAddr + i);
}
//====================================================================================================
//	Description:	Fade Out Effect
//	Function:		FadeOut()
//	Syntax:			void	FadeOut(void);
//	Input Paramter:	none
//	Return: 		none
//====================================================================================================
void FadeOut(void)    
{
	U32 i, j;
	for(i=0; i<256; i++)
	{
		*P_TV_FADE = i;
		for(j=0; j<1024*6; j++);
	}
}
//====================================================================================================
//	Description:	Fade In Effect
//	Function:		FadeIn()
//	Syntax:			void	FadeIn(void);
//	Input Paramter:	none
//	Return: 		none
//====================================================================================================
void FadeIn(void)     
{
	U32 i, j;
	for(i=0; i<256; i++)
	{
		*P_TV_FADE = 255-i;
		for(j=0; j<1024*8; j++);
	}
}

//==========================================
// Function:     SetColorPalette();
// Syntax:       void PPU_SP_SetPalette(U16 col_st, U16 number, U32 *pSPPalAddr)
// Description:  Set One Color to Palette
// Notes:        none
// parameters:	 int col_st: Color Start Index
//				 int col_end: Color End Index
//				 int value: Color Value
// returns: 	 none
//==========================================
void PPU_SP_SetPalette(U16 col_st, U16 number, U32 *pSPPalAddr)
{
	U32 i,j;

	for (i = col_st, j = 0; i < (col_st+number); i++,j++)//no safe
		*(P_SP_COLOR_PALETTE + i)	= *(pSPPalAddr + j);
}