chiplib.c

s1d13716的源码 windiws ce 或8位单片机

//---------------------------------------------------------------------------
//	GetPll()
//---------------------------------------------------------------------------

UInt32 GetPll( int *error )
{
	UInt32 N, L, V, pll;
	UInt32 Kv;
	UInt8 reg10, reg11;
	UInt32 factor;
	int tmp;
	UInt32 PllClk;

	// The error would be set to NULL if the caller doesn't
	// want to get the error.
	if ( error == NULL )
		error = &tmp;


	*error = FALSE;

	// Determine if the PLL clock is the CLKI External Clock Source,
	// or the 32 kHz External Oscillator.
	if ( halReadReg8(REG0014_CLKSRC) & 0x02 )
		PllClk = 32768;  // 32 kHz
	else
		PllClk = HalInfo.dwClkI;


	reg10 = halReadReg8( REG0010_PLL0 );
	reg11 = halReadReg8( REG0011_PLL1 );

	N = reg11 >> 4;
	L = ((reg11&0x0f)<<6) | (reg10>>2);

	pll = (N+1) * (L+1) * PllClk;


	//
	// If the duty cycle is not important, lower power consumption can be achieved
	// by setting the V-divider bits and VCO Kv Set bits to 0.
	//
	// Don't check these bits if PLL Low Power mode has been configured.
	//
	if ( !(HalInfo.dwFlags&fPLL_LOWPOWER) )
		{
		// Verify if PLL registers programmed correctly
		V = 1 << (reg10 & 0x03);
		Kv = halReadReg16(REG0012_PLL2) >> 4;
		
		factor = pll * V;
		
		if ( (100*MHZ<=factor) && (factor<=410*MHZ) )
			{
			if ( (100*MHZ<=factor) && (factor<=200*MHZ) )
				{
				if ( Kv != 2 )
					*error = TRUE;
				}
			else if ( (200*MHZ<factor) && (factor<=300*MHZ) )
				{
				if ( Kv != 5 )
					*error = TRUE;
				}
			else if ( (300*MHZ<factor) && (factor<=410*MHZ) )
				{
				if ( Kv != 7 )
					*error = TRUE;
				}
			}
		else
			*error = TRUE;
		}

	return pll;
}

//----------------------------------------------------------------------------
// GetPllMuxOutputFreq()
//----------------------------------------------------------------------------

UInt32 GetPllMuxOutputFreq( SrcClkDef *pSrcClk, PllMuxErrorDef *pPllMuxError )
{
	UInt32 PllMuxOutputFreq = 0;
	UInt8 reg14 = halReadReg8( REG0014_CLKSRC );

	// Default to no PLL Multiplexer errors
	if ( pPllMuxError != NULL )
		*pPllMuxError = PLLMUXERR_NONE;

	if ( reg14 & 0x01 )  // Internal PLL selected
	{
		int PllError;
		PllMuxOutputFreq = GetPll( &PllError );

		// If there is an error determining the PLL frequency,
		// update PLL Multiplexer error (unless pPllMuxError is NULL).
		if ( pPllMuxError != NULL )
		{
			if ( PllError )
				*pPllMuxError = PLLMUXERR_INVALID_VALUE;
			// If the external clock source is selected for the PLL reference, then
			// ensure that this reference frequency is 32.768 kHz.
			else if ( ((reg14&0x02)==0) && (HalInfo.dwClkI!=32768) )
				*pPllMuxError = PLLMUXERR_CLKI_NOT_32768;
		}

		if ( pSrcClk != NULL )
			*pSrcClk = SRC_PLL;
	}
	else
	{
		PllMuxOutputFreq = HalInfo.dwClkI;

		if ( pSrcClk != NULL )
			*pSrcClk = SRC_CLKI;
	}

	return PllMuxOutputFreq;
}

//----------------------------------------------------------------------------
// GetI2cClkDivide()
//----------------------------------------------------------------------------

int GetI2cClkDivide(void)
{
	int val;

	val = (halReadReg8(REG0015_SERLCDCLK)>>3) & 0x0f;

	if ( val == 0 )
		return 1;
	else
		return val * 2;
}

//----------------------------------------------------------------------------
// GetI2cClock()
//----------------------------------------------------------------------------

UInt32 GetI2cClock( SrcClkDef *pSrcClk, PllMuxErrorDef *pPllMuxError )
{
	UInt8 reg18 = halReadReg8( REG0018_POWERSAVE );
	UInt32 PllMuxOutputFreq = GetPllMuxOutputFreq(pSrcClk,pPllMuxError);

	if ( reg18 & 0x01 )
		return 0;  // I2C clock is 0 in powersave mode
	else
	{
	return PllMuxOutputFreq / GetI2cClkDivide();
	}
}

//----------------------------------------------------------------------------
// GetSystemClkDivide()
//----------------------------------------------------------------------------

int GetSystemClkDivide(void)
{
	return ((halReadReg8(REG0014_CLKSRC)>>2)&0x03) + 1;
}

//----------------------------------------------------------------------------
// GetSystemClock()
//----------------------------------------------------------------------------

UInt32 GetSystemClock( SrcClkDef *pSrcClk, PllMuxErrorDef *pPllMuxError )
{
	UInt8 reg18 = halReadReg8( REG0018_POWERSAVE );
	UInt32 PllMuxOutputFreq = GetPllMuxOutputFreq(pSrcClk,pPllMuxError);

	if ( reg18 & 0x01 )
		return 0;  // System clock is 0 in powersave mode
	else
	{
	return PllMuxOutputFreq / GetSystemClkDivide();
	}
}

//----------------------------------------------------------------------------
// GetParallelPanelClkDivide()
//----------------------------------------------------------------------------

UInt32 GetParallelPanelClkDivide( void )
{
	return ((halReadReg8(REG0014_CLKSRC)>>4)+1) * 2;
}

//----------------------------------------------------------------------------
// GetParallelPanelClkFreq()
//----------------------------------------------------------------------------

UInt32 GetParallelPanelClkFreq( void )
{
	return GetSystemClock( NULL, NULL ) / GetParallelPanelClkDivide();
}

//----------------------------------------------------------------------------
// GetSerialLcdClkDivide()
//----------------------------------------------------------------------------

int GetSerialLcdClkDivide( void )
{
	return ((halReadReg8(REG0015_SERLCDCLK)&0x07)+1) * 2;
}

//----------------------------------------------------------------------------
// GetSerialLcdClkFreq()
//----------------------------------------------------------------------------

UInt32 GetSerialLcdClkFreq( void )
{
	return GetSystemClock( NULL, NULL ) / GetSerialLcdClkDivide();
}

//----------------------------------------------------------------------------
// GetCameraClkDivide()
//----------------------------------------------------------------------------

int GetCameraClkDivide( void )
{
	return ((halReadReg8(REG0100_CMCLK)&0x0f)+1) * 2;
}

//----------------------------------------------------------------------------
// GetCameraClkOutFreq()
//----------------------------------------------------------------------------

UInt32 GetCameraClkOutFreq( void )
{
	return GetSystemClock( NULL, NULL ) / GetCameraClkDivide();
}

//----------------------------------------------------------------------------
// SetOutputPort()
//----------------------------------------------------------------------------

Boolean SetOutputPort( OutputPortDef port )
{
	UInt8 reg = (UInt8)(halReadReg8(REG004C_DISPSETTING)&~0x03);

	switch (port)
		{
		case cl_PORT_ALL_OFF:	break;
		case cl_PORT_LCD1:		reg |= 0x01; break;
		case cl_PORT_LCD2:		reg |= 0x02; break;
		case cl_PORT_LCD3:		reg |= 0x03; break;
		default: return FALSE;
		}

	halWriteReg8( REG004C_DISPSETTING, reg );
	return TRUE;
}

//----------------------------------------------------------------------------
// GetOutputPort()
//----------------------------------------------------------------------------

OutputPortDef GetOutputPort( void )
{
	UInt8 PortStatus = (UInt8) (halReadReg8(REG004C_DISPSETTING) & 0x03);

	switch (PortStatus)
		{
		default:
		case 0:  return cl_PORT_ALL_OFF; break;
		case 1:  return cl_PORT_LCD1; break;
		case 2:  return cl_PORT_LCD2; break;
		case 3:  return cl_PORT_LCD3; break;
		}
}


//----------------------------------------------------------------------------
// SetLutBypassEnable()
//----------------------------------------------------------------------------

void SetLutBypassEnable( Boolean enable )
{
	UInt8 reg = halReadReg8(REG004C_DISPSETTING);

	if (enable)
		reg &= ~0x0010;
	else
		reg |= 0x0010;  // LUT bypass disabled

	halWriteReg8(REG004C_DISPSETTING, reg);
}

//----------------------------------------------------------------------------
// GetLutBypassEnable()
//----------------------------------------------------------------------------

int GetLutBypassEnable( WindowDef Window )
{
	if ( Window == cl_OVERLAY_WINDOW )
		return (halReadReg8(REG004C_DISPSETTING) & 0x10) ? FALSE : TRUE;
	else
		return TRUE;
}

//----------------------------------------------------------------------------
// GetLutMode()
//----------------------------------------------------------------------------

UInt32 GetLutMode( WindowDef Window )
{
	int bpp;
	Boolean LutBypass;

	bpp = GetBitsPerPixel(Window);
	LutBypass = GetLutBypassEnable(Window);

	if (LutBypass)
		{
		switch (bpp)
			{
			case 8:  return cl_LUT_BYPASS_8BPP_332RGB;   break;
			case 16: return cl_LUT_BYPASS_16BPP_565RGB;  break;
			default: return cl_LUT_ERROR; break;
			}
		}
	else
		{
		switch (bpp)
			{
			case 8:  return cl_LUT_NOBYPASS_8BPP_256COLOR_LUT;   break;
			case 16: return cl_LUT_NOBYPASS_16BPP_565LUT;  break;
			default: return cl_LUT_ERROR; break;
			}
		}
}

//----------------------------------------------------------------------------
// PowerSaveMode()
//----------------------------------------------------------------------------

void PowerSaveMode( Boolean enable )
{
	UInt8 reg0018;

	reg0018 = halReadReg8( REG0018_POWERSAVE );

	if (enable)   // Enable Power Save Mode
		{
		// Enable Power Save mode
		reg0018 |= 0x01;
		halWriteReg8( REG0018_POWERSAVE, reg0018 );
		}
	else
		{
		// Disable Power Save mode
		reg0018 &= ~0x01;
		halWriteReg8( REG0018_POWERSAVE, reg0018 );
		}
}

//---------------------------------------------------------------------------
//  FUNCTION: isHostIndirectInterface()
//---------------------------------------------------------------------------
Boolean isHostIndirectInterface( void )
{
	return TRUE;	// The S1D13716 is always using the indirect interface
}

//---------------------------------------------------------------------------
//  FUNCTION: clStartOneFrameTransfer()
//---------------------------------------------------------------------------
Boolean clStartOneFrameTransfer( void )
{
	// Don't issue a frame transfer if no port is active
	if ( GetOutputPort() == cl_PORT_ALL_OFF )
		return FALSE;

	// Don't wait for busy bit if in auto frame transfer mode
	if ( (halReadReg8(REG003C_LCDXFER) & 0x01) == 0 )
	{
		while ( 0 != (0x01 & halReadReg8(REG0038_LCDSTATUS)) )
			continue;
	}

	halWriteReg8( REG003A_LCDFRAMEXFER, 1 );

	return TRUE;
}

//---------------------------------------------------------------------------
//	FUNCTION:		SetSwivelViewMode()
//---------------------------------------------------------------------------
void SetSwivelViewMode(WindowDef window, int mode)
{
	UInt8 swivel;
	Boolean fswivel;

	swivel=halReadReg8(REG024A_SWIVELVIEW);
	if(window==cl_OVERLAY_WINDOW)
	{
		fswivel=swivel & 0x03;
		if(!fswivel)
			return;
		else
			halWriteReg8(REG024A_SWIVELVIEW, swivel | 0x10);
	}

	swivel &=0xFc;
	switch(mode)
	{
	case 0:
		halWriteReg8(REG024A_SWIVELVIEW,swivel);
		break;		
	case 90:	
		halWriteReg8(REG024A_SWIVELVIEW,swivel |0x01);
		break;
	case 180:
		halWriteReg8(REG024A_SWIVELVIEW,swivel |0x02);
		break;
	case 270:
		halWriteReg8(REG024A_SWIVELVIEW,swivel |0x03);
		break;
	}
}

//----------------------------------------------------------------------------
// SetWinMirror()
//----------------------------------------------------------------------------
void SetWinMirror(WindowDef window, Boolean Enable)
{
	UInt8 reg;

	switch (window)
		{
		default:
		case cl_MAIN_WINDOW:
			reg = (UInt8) (halReadReg8(REG024A_SWIVELVIEW) & ~0x04);
			SelectHostImage(window);
			if (Enable)
				reg |= 0x04;
			break;

		case cl_OVERLAY_WINDOW:
			reg = (UInt8) (halReadReg8(REG024A_SWIVELVIEW) & ~0x10);
			SelectHostImage(window);
			if (Enable)
				reg |= 0x0010;
			break;
		}

	halWriteReg8(REG024A_SWIVELVIEW, reg);
}

//---------------------------------------------------------------------------
//	FUNCTION:		SetOverlayEnable()
//---------------------------------------------------------------------------
void SetOverlayEnable(Boolean Enable)
{
	UInt8 reg = halReadReg8(REG004C_DISPSETTING);

	reg &= ~0x40;

	if(Enable)
		reg |= 0x40;
	halWriteReg8(REG004C_DISPSETTING, reg);
}

//---------------------------------------------------------------------------
//	FUNCTION:		SetOverlayEnable()
//---------------------------------------------------------------------------
void SelectHostImage(WindowDef window)
{
	if(cl_MAIN_WINDOW==window)
		halWriteReg8(REG0248_OIMAGE, 0);
	else
		halWriteReg8(REG0248_OIMAGE, 0x10);
}

//---------------------------------------------------------------------------
//	FUNCTION:		SetMainPosition()
//---------------------------------------------------------------------------
void SetMainPosition(UInt32 xStart, UInt32 yStart, UInt32 xEnd, UInt32 yEnd)
{
	UInt8 width;
	UInt8 height;
	Boolean fresize;
	
	width = xEnd-xStart-1;
	height = yEnd-yStart-1;
	
	halWriteReg8(REG0212_MEMHORZRES,width);
	halWriteReg8(REG0214_MEMVERTRES,height);
	halWriteReg8(REG0228_XOFFSET0, (UInt8) xStart);
	halWriteReg8(REG0229_XOFFSET1, (UInt8) xStart>>8);
	halWriteReg8(REG022A_YOFFSET0, (UInt8) yStart);
	halWriteReg8(REG022B_YOFFSET1, (UInt8) yStart>>8);

	//It seem resize width and height must be set same as up setting.

	//if(fresize)
	//{
	//	;
	//}	
}