chipdef.cpp

用C语言设计的EPSON LCD控制器S1D13700驱动。

//============================================================================
//
//  CHIPDEF.CPP
//
//  Copyright (c) Seiko Epson Corporation 2003-2005 
//  All rights reserved.
//
//    The tabs in the file is formatted at 4.
//
//============================================================================




#ifdef _WIN32
#pragma warning( disable : 4100 )	// Disable "unreferenced formal parameter" warning.
#pragma warning( disable : 4127 )	// Disable "conditional expression is constant" warning.
#pragma warning( disable : 4800 )	// Disable "forcing value to bool 'true' or 'false' (performance warning)" warning.
#include <windows.h>
#endif
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#define HAL_ACCESS_PRIVATE_DATA
#include "hal.h"
#include "chipdef.h"
#include "graphics.h"
#include "hal_indirect.h"



// Define some useful pre-processor macros.
#if defined(IndexAndMaskMatch) || defined(NL) || defined(DOTEXT) || defined(DODIAGTEXT) || defined(FEATUREIS)
#error A chipdef.cpp pre-processor macro is already in use!
#else
#define		NL							"\n"
#define		DOTEXT						iT += sprintf( Text+iT,
#define		DODIAGTEXT(feature,str)		iT += _snprintf( Text+iT, Size-iT, str, GetFeatureName(feature,GN_NAME|GN_REG|GN_SHORT)
#define		FEATUREIS(feature)			strcmp(feature,Keyname)==0
#endif

#define		sprintfClockField(clk)		(clk)/1000000, ((clk)/1000)%1000

#define		HALSIGSUFFIX				" HAL EXE"
static char	szHalSignature[16];

const char* ChipDefXML[] =
{
#include "chipdefxml.hc"
};
const int nChipDefXMLLines = sizeof(ChipDefXML)/sizeof(ChipDefXML[0]);

#define		EMBEDDED_DISPLAY_MEM_SIZE 32768
extern HSTRPOOL		g_SP;			// Handle to a pool of recycles strings.


//=============================PUBLIC=AREA====================================




ChipDef::ChipDef( ) : ChipDefBase( ),
	m_HalInfo( ::HalInfo )			// Instantiate this's HalInfo structure from HAL's default master.
{
	m_DefaultRegIndexField = 4;

	strcpy( szHalSignature, m_HalInfo.szChipId );
	strcat( szHalSignature, HALSIGSUFFIX );

	LoadXML( ChipDefXML, nChipDefXMLLines );

	for ( m_MaxHalInfoRegIndex=0; m_HalInfo.Regs[m_MaxHalInfoRegIndex].Index!=REGFLAG_ENDOFTABLE; m_MaxHalInfoRegIndex++ )
		continue;

	// Check HAL to see what chip variant we are now.
	if ( SetProduct(m_HalInfo.szChipId) == false )
	assert( false );	// Wrong product ID in HALInfo?!?

	CalculateMinMaxForSpans( );
	FilterHALRegisterList( );
}


ChipDef::~ChipDef( )
{
}



bool ChipDef::SetProduct( in const char* Keyname )
{
	if ( ChipDefBase::SetProduct(Keyname) )
	{
		strcpy( m_HalInfo.szChipId, Keyname );
		return true;
	}

	return false;
}




bool ChipDef::EnuMemMap( in int Base, in UInt32 Index, out char* AddrName, out UInt32* StartAddr, out UInt32* EndAddr )
{
	#define AddMA(F,SA,EA,L)	if (Base&(F)) {MA[nMA].StartAddr=(SA);  MA[nMA].EndAddr=(EA);  MA[nMA].Flags=(F);  if ((Base&AB_SYSWIDE)&&((F)&AB_SYSWIDE)&&((F)&AB_CHIPDISP)) {strcpy(MA[nMA].Label,"-"); strcat(MA[nMA].Label,(L));} else strcpy(MA[nMA].Label,(L));  nMA++;}
	UInt32  SysBase = 0;
	UInt32  DispBase = 0;
	MemAddr MA[10];
	int		nMA = 0;

	switch ( Base )
	{
		case AB_SYSWIDE:	SysBase=GetFeatureNumValue("baseaddr");	DispBase=SysBase+GetFeatureNumValue("memoffset");	break;
		case AB_CHIPBASE:	SysBase=0;								DispBase=GetFeatureNumValue("memoffset");			break;
		case AB_CHIPDISP:	SysBase=0;								DispBase=0;											break;
	}

	AddMA( AB_SYSWIDE|AB_CHIPBASE,		SysBase+GetFeatureNumValue("regoffset"),	SysBase+0x003FFFFF,		"Registers" )
	AddMA( AB_SYSWIDE|AB_CHIPBASE,		SysBase+GetFeatureNumValue("memoffset"),	SysBase+0x003A8000,"	Display Memory" )
	AddMA( AB_SYSWIDE,					SysBase,									0,						"Chip Base Address" )

	qsort( MA, nMA, sizeof(MemAddr), CompareMemAddresses );

	if ( (int)Index < nMA )
	{
		strcpy( AddrName, MA[Index].Label );
		*StartAddr = MA[Index].StartAddr;
		*EndAddr = MA[Index].EndAddr;
		return true;
	}

	return false;
}




int ChipDef::CompareMemAddresses( in const void* First, in const void* Second )
{
	MemAddr* F = (MemAddr*)First;
	MemAddr* S = (MemAddr*)Second;

	// Note: the following code sorts addresses into DESCENDING order.
	if ( F->Flags > S->Flags )
		return -1;
	else if ( F->Flags < S->Flags )
	return 1;
	else if ( F->StartAddr > S->StartAddr )
	return -1;
	else if ( F->StartAddr < S->StartAddr )
	return 1;
	return 0;
}




UInt32 ChipDef::GetFeatureRawValue( in const char* Keyname )
{
	static const UInt32    iParDW[8] = { 8, 8, 16, 8, 24, 16, 16, 18 };
	static const int    iParDF[8] = { 0, 1, 4, 4, 4, 1, 2, 3 };
	UInt32 iFeature;

	if ( LookupFeature(Keyname,&iFeature) )
	{
		if ( m_Features[iFeature].NeedCode )
		{
			if		( FEATUREIS("baseaddr") )		return GetHotChip() ? gpHalData->BaseAddress : m_HalInfo.dwBaseAddress;
			else if ( FEATUREIS("regaddr") )		return GetHotChip() ? gpHalData->RegisterAddress : (m_HalInfo.dwBaseAddress+GetFeatureRawValue("regoffset"));
			else if ( FEATUREIS("memaddr") )		return GetHotChip() ? gpHalData->MemoryAddress : (m_HalInfo.dwBaseAddress+GetFeatureRawValue("memoffset"));
			else if ( FEATUREIS("regoffset") )		return GetHotChip() ? (gpHalData->RegisterAddress-gpHalData->BaseAddress) : m_HalInfo.dwRegisterOffset;
			else if ( FEATUREIS("memoffset") )		return GetHotChip() ? (gpHalData->MemoryAddress-gpHalData->BaseAddress) : m_HalInfo.dwMemoryOffset;
			else if ( FEATUREIS("framerate") )		return GetFrameRate( 0 );
			else if ( FEATUREIS("vram") )			return m_HalInfo.dwRequiredVRAM;
			else if ( FEATUREIS("ii") )				return !!(m_HalInfo.dwFlags & fINDIRECT_INTERFACE);
			else if ( FEATUREIS("pccard") )			return !!(m_HalInfo.dwFlags & fPCCARD_INTERFACE);
			else if ( FEATUREIS("regwrite") )		return !!(m_HalInfo.dwFlags & fDEBUG_REG_WRITES);
			else if ( FEATUREIS("clki") )			return m_HalInfo.dwClkI;
			else if ( FEATUREIS("iosc") )			return m_HalInfo.dwInternalOSC;
			else if ( FEATUREIS("sysclk") )			return (GetFeatureRawValue("sysclksrc")?(GetFeatureRawValue("clki")):(GetFeatureRawValue("iosc")));
			else if ( FEATUREIS("sysclksrc") )		return !!(m_HalInfo.dwFlags & fSOURCE_CLKI);
			else if ( FEATUREIS("fpshiftdiv") )		return ((!!(m_HalInfo.dwFlags&fCNF1)<<1)+(!!(m_HalInfo.dwFlags&fCNF0)));
			else if ( FEATUREIS("fpshiftclk") )		return GetFeatureRawValue("sysclk") / (1<<(GetFeatureNumValue("fpshiftdiv")+2));
			else if ( FEATUREIS("pclkdiv") )		
			{
				switch ( GetFeatureRawValue("fpshiftdiv") )
				{
					default:
					case 0:  return 1 * GetFeatureNumValue( "bpp" );
					case 1:  return 2 * GetFeatureNumValue( "bpp" );
					case 2:  return 4 * GetFeatureNumValue( "bpp" );
				}
			}
			else if ( FEATUREIS("pclk") )			return GetFeatureRawValue("sysclk") / GetFeatureNumValue("pclkdiv");
			else if ( FEATUREIS("bufsize") )		return 0x8000;   // 32k bytes
			else if ( FEATUREIS("width") )			return ( GetFeatureRawValue("stride") + 1 ) * 8 / GetFeatureRawValue("bpp");
			else if ( FEATUREIS("height") )			return GetFeatureRawValue("lf") + 1 ;
			else if ( FEATUREIS("stride") )			return ChipDefBase::GetFeatureRawValue( "stride" );
			else if ( FEATUREIS("bpp") )
			{
				switch ( GetFeatureRawValue("rawbpp") )
				{
					default:
					case 0:  return 1;
					case 1:  return 2;
					case 2:  return 4;
				}
			}
		}

		return ChipDefBase::GetFeatureRawValue( Keyname );
	}
	assert( false ); // ERROR: Keyname doesn't exist for this product!  Caller must test IsFeatureValid() first!
	return 0;
}




UInt32 ChipDef::GetFeatureMinValue( in const char* Keyname )
{
	UInt32 iFeature;

	if ( LookupFeature(Keyname,&iFeature) )
	{
		assert( m_Features[iFeature].Type==FT_NUMB || m_Features[iFeature].Type==FT_ADDR || m_Features[iFeature].Type==FT_FREQ );

		if ( m_Features[iFeature].NeedCode )
		{
			if ( FEATUREIS("baseaddr") )            return 0;
			else if ( FEATUREIS("regoffset") )      return 0;
			else if ( FEATUREIS("memoffset") )      return 0;
			else if ( FEATUREIS("vram") )           return 0;
			else if ( FEATUREIS("clki") )           return 390000;
			else if ( FEATUREIS("iosc") )           return 20000000;
			else if ( FEATUREIS("pclk") )			return GetFeatureMinValue("sysclk");
			else if ( FEATUREIS("fpshiftclk") )		return GetFeatureMinValue("sysclk");
		}

		return ChipDefBase::GetFeatureMinValue( Keyname );
	}
	assert( false ); // ERROR: Keyname doesn't exist for this product!  Caller must test IsFeatureValid() first!
	return 0;
}




UInt32 ChipDef::GetFeatureMaxValue( in const char* Keyname )
{
	UInt32 iFeature;

	if ( LookupFeature(Keyname,&iFeature) )
	{
		assert( m_Features[iFeature].Type==FT_NUMB || m_Features[iFeature].Type==FT_ADDR || m_Features[iFeature].Type==FT_FREQ );
		if ( m_Features[iFeature].NeedCode )
		{
			if ( FEATUREIS("baseaddr") )			return maxof(m_HalInfo.dwBaseAddress);
			else if ( FEATUREIS("regoffset") )		return maxof(m_HalInfo.dwRegisterOffset);
			else if ( FEATUREIS("memoffset") )		return maxof(m_HalInfo.dwMemoryOffset);
			else if ( FEATUREIS("vram") )			return maxof(m_HalInfo.dwRequiredVRAM);
			else if ( FEATUREIS("clki") )			return 120000000;
			else if ( FEATUREIS("iosc") )			return 30000000;
			else if ( FEATUREIS("pclk") )			return GetFeatureMaxValue("sysclk");
			else if ( FEATUREIS("fpshiftclk") )		return GetFeatureMaxValue("sysclk");
		}

		return ChipDefBase::GetFeatureMaxValue( Keyname );
	}

	assert( false ); // ERROR: Keyname doesn't exist for this product!  Caller must test IsFeatureValid() first!
	return 0;
}




const char* ChipDef::GetFeatureStrValue( in const char* Keyname, in bool OnRead )
{
	UInt32 iFeature;

	if ( LookupFeature(Keyname,&iFeature) )
	{
		if ( m_Features[iFeature].NeedCode )
		{
			if ( FEATUREIS("chipid") )			return GetProductName(NULL,GN_NAME);
				else if ( FEATUREIS("chipname") )	return GetProductName(NULL,GN_NAME|GN_PREFIX|GN_SUFFIX);
			else if (   FEATUREIS("chipdesc") )	return GetProductName(NULL,GN_DESC);
			else if (   FEATUREIS("cfgdesc") )	return m_HalInfo.szConfigString;
			else if (   FEATUREIS("clki")		||
						FEATUREIS("iosc")		||
						FEATUREIS("sysclk")		||
						FEATUREIS("pclk")		||
						FEATUREIS("fpshiftclk")	||
						FEATUREIS("framerate") )
					return hztoa( GetFeatureNumValue(Keyname), true );
			else if ( FEATUREIS("pclksrc") )
			{
				char*  Text = GetCircularStr( m_SP );
				strcpy( Text, "sysclk");
				return Text;
			}
		}

		return ChipDefBase::GetFeatureStrValue( Keyname, OnRead );
	}

	assert( false ); // ERROR: Keyname doesn't exist for this product!  Caller must test IsFeatureValid() first!
	return NULL;
}




bool ChipDef::SetFeatureRawValue( in const char* Keyname, in UInt32 RawValue )
{
	#define SETFEATUREHALFLAG(halflag,invert)	{  m_HalInfo.dwFlags &= ~(halflag);	if (invert)	m_HalInfo.dwFlags |= (-!RawValue & (halflag));	else	m_HalInfo.dwFlags |= (-!!RawValue & (halflag));	}