chipdefbase.cpp

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

{
	assert( false );	// The chip-specific class should have handled this!
	return false;
}




bool ChipDefBase::IsRegisterValid( in UInt32 Index, in bool IsHALIndex )
{
	UInt32 iRegister;

	if ( LookupRegister(Index,IsHALIndex,&iRegister) )
		return MatchToCurrentProduct( m_Registers[iRegister].Product );
	return false;
}




bool ChipDefBase::IsRegisterReserved( in UInt32 Index, in bool IsHALIndex )
{
	UInt32 iRegister;

	if ( LookupRegister(Index,IsHALIndex,&iRegister) )
		return m_Registers[iRegister].Reserved && MatchToCurrentProduct( m_Registers[iRegister].Reserved );
	assert( false ); // ERROR: this wouldn't happen if IsRegisterValid() was called first!
	return false;
}


bool ChipDefBase::IsRegisterSafeTest( in UInt32 Index, in bool IsHALIndex )
{
	UInt32 iRegister;

	if ( LookupRegister(Index,IsHALIndex,&iRegister) )
		return m_Registers[iRegister].fSafeTest;
	assert( false ); // ERROR: this wouldn't happen if IsRegisterValid() was called first!
	return false;
}


bool ChipDefBase::IsRegisterReadOnly( in UInt32 Index, in bool IsHALIndex )
{
	UInt32 iRegister;

	if ( LookupRegister(Index,IsHALIndex,&iRegister) )
		return m_Registers[iRegister].ReadOnly;
	assert( false ); // ERROR: this wouldn't happen if IsRegisterValid() was called first!
	return false;
}




bool ChipDefBase::IsRegisterWriteOnly( in UInt32 Index, in bool IsHALIndex )
{
	UInt32 iRegister;

	if ( LookupRegister(Index,IsHALIndex,&iRegister) )
		return m_Registers[iRegister].WriteOnly;
	assert( false ); // ERROR: this wouldn't happen if IsRegisterValid() was called first!
	return false;
}




const char* ChipDefBase::GetRegisterName( in UInt32 Index, in bool IsHALIndex, in int Flags )
{
	UInt32 iRegister;

	if ( LookupRegister(Index,IsHALIndex,&iRegister) )
	{
		char*  Name = GetCircularStr( m_SP );
		int    iName;

		if ( Flags & GN_LEX )
		{
			if ( m_Registers[iRegister].FakeReg )
				strcpy( Name, "REGFLAG_" );
			else
				sprintf( Name, "REG%0*X_", m_DefaultRegIndexField, m_Registers[iRegister].RegIndex );
			strcat( Name, m_Registers[iRegister].Keyname );
			_strupr( Name );
		}
		else
		{
			if ( Flags & GN_REG )
				sprintf( Name, "REG[%0*Xh]", m_DefaultRegIndexField, Index );
			if ( Flags & GN_NAME )
			{
				if ( Name[0] != '\0' )
					strcat( Name, " " );
				strcat( Name, m_Registers[iRegister].Name );
			}
			if ( Flags & GN_ATTRS )
			{
				bool Reserved = m_Registers[iRegister].Reserved && MatchToCurrentProduct(m_Registers[iRegister].Reserved);

				if ( Name[0] != '\0' )
					strcat( Name, " " );
				if ( m_Registers[iRegister].ReadOnly || m_Registers[iRegister].WriteOnly || Reserved )
					strcat( Name, "[" );
				if ( m_Registers[iRegister].ReadOnly )
					strcat( Name, ((Flags&GN_SHORT)?"RO,":"READONLY,") );
				else if ( m_Registers[iRegister].WriteOnly )
					strcat( Name, ((Flags&GN_SHORT)?"WO,":"WRITEONLY,") );
				if ( Reserved )
					strcat( Name, ((Flags&GN_SHORT)?"RSVD,":"RESERVED,") );
				if ( m_Registers[iRegister].ReadOnly || m_Registers[iRegister].WriteOnly || Reserved )
				{
					iName = strlen(Name);	// Strip off the last comma.
					Name[iName-1] = '\0';
					strcat( Name, "] " );
				}
			}

			// Get rid of last space.
			iName = strlen(Name) - 1;
			if ( Name[iName] == ' ' )
				Name[iName] = '\0';
		}
		return Name;
	}
	assert( false ); // ERROR: this wouldn't happen if IsRegisterValid() was called first!
	return 0;
}


const char* ChipDefBase::GetRegisterCategory( in UInt32 Index, in bool IsHALIndex )
{
	UInt32 iRegister;

	if ( LookupRegister(Index,IsHALIndex,&iRegister) )
		return (m_Registers[iRegister].Category==NULL) ? "" : m_Registers[iRegister].Category;
	assert( false ); // ERROR: this wouldn't happen if IsRegisterValid() was called first!
	return 0;
}



const char* ChipDefBase::GetRegisterDesc( in UInt32 Index, in bool IsHALIndex )
{
	UInt32 iRegister;

	if ( LookupRegister(Index,IsHALIndex,&iRegister) )
		return (m_Registers[iRegister].Desc==NULL) ? "" : m_Registers[iRegister].Desc;
	assert( false ); // ERROR: this wouldn't happen if IsRegisterValid() was called first!
	return 0;
}




const char* ChipDefBase::GetRegisterSummary( in UInt32 Index, inout char* TextBuf, in bool IsHALIndex, in char* LinePrefix, in char* LineTerminator, in int NumTextCols, in bool ShortSummary )
//
//                         S H O R T   S U M M A R Y
//
// REG[000Eh] PLL Setting Register
//     b15:12 N-Counter = 1 lines
//      b11:2 L-Counter = 823
//       b1:0 CLK Source = CLKI
//
//                          L O N G   S U M M A R Y
//
// REG[0110h] Camera Mode Setting Register
// +--------+--------+--------+--------+--------+--------+--------+--------+
// |::::::::|::::::::|::::::::|::::::::|::::::::|camyuv  |camyuvdatatype   :
// |::::::::|::::::::|::::::::|::::::::|::::::::|yuvconv |                 :
// +---15---+---14---+---13---+---12---+---11---+---10---+----9---+----8---+
// :        |camitur |camitur |cam2    |cam1    |cammode          |camclk  |
// :        |        |enable  |pulldown|pulldown|                 |output  |
// +----7---+----6---+----5---+----4---+----3---+----2---+----1---+----0---+
//
//     camyuvdatatype  Horizontal Display Period [RESERVED]
//                     This specify the position of the FPLINE pulse.
//                     = REG[0112-b5:0]<<16 + REG[0110-b15:0]
//                     = 1h<<16 + 7Eh
//                     = 243 pixels
// 
//            camitur  Something Cycle Time [READONLY]
//              Bit 6  This specifies something, I don't know what, but something.
//                     = REG[004A-b7]
//                     = 23h
//                     = 35 pin-pricks
//                     Possible Values:
//                     0h = Disabled
//                     1h = Enabled
//
//     (etc.)
//
{
	UInt32 i;
	UInt32 iRegister;
	UInt32 RegValue = 0;

	if ( !LookupRegister(Index,IsHALIndex,&iRegister) )
	{
		sprintf( TextBuf+strlen(TextBuf), "REG[%0*Xh] does not exist for this chip.", m_DefaultRegIndexField, Index );
		return TextBuf;
	}

	if ( !IsRegisterWriteOnly(Index,IsHALIndex) )
		RegValue = GetRegisterValue( Index, IsHALIndex );

	TextBuf[0] = '\0';
	if ( ShortSummary )
	{
		if (LinePrefix) strcat( TextBuf, LinePrefix );
		strcat( TextBuf, GetRegisterName(Index,IsHALIndex,GN_NAME|GN_REG|GN_ATTRS|GN_SHORT) );

		for ( i=0; i<m_NumFeatures; i++ )
		{
			if ( !m_Features[i].Overlap && m_Features[i].RegIndex==m_Registers[iRegister].RegIndex && m_Features[i].RegMask!=0xFFFFFFFF )
			{
				if ( MatchToCurrentProduct(m_Features[i].Product) && (m_DebugMode || !IsFeatureReserved(m_Features[i].Keyname)) )
				{
					if (LineTerminator) strcat( TextBuf, LineTerminator );
					if (LinePrefix) strcat( TextBuf, LinePrefix );
					sprintf( TextBuf+strlen(TextBuf), "%*s %s", 10, GetFeatureName(m_Features[i].Keyname,GN_BITS|GN_SHORT), GetFeatureName(m_Features[i].Keyname,GN_NAME|GN_ATTRS|GN_SHORT) );
					if ( !IsFeatureWriteOnly(m_Features[i].Keyname) )
					{
						strcat( TextBuf, " = " );
						strcat( TextBuf, GetFeatureStrValue(m_Features[i].Keyname,GetFeatureRawBits(i,RegValue)) );
					}
				}
			}
		}
	}
	else
	{
		static const int InnerCellWidth = 8;
		UInt32			 MaxBitsPerRow = max( 8, (((NumTextCols-1)/(InnerCellWidth+1))/8)*8 );
		UInt32			 NumRows = (m_Registers[iRegister].BitWidth<=MaxBitsPerRow) ? 1 : (m_Registers[iRegister].BitWidth/MaxBitsPerRow);
		UInt32			 NumCols = m_Registers[iRegister].BitWidth / NumRows;
		char*			 BottomRow = GetCircularStr( m_SP );
		char*			 LegendRow = GetCircularStr( m_SP );
		bool			 BitfieldWrap = false;

		// Print register name.
		if (LinePrefix) strcat( TextBuf, LinePrefix );
		strcat( TextBuf, GetRegisterName(Index,IsHALIndex,GN_NAME|GN_REG|GN_ATTRS) );

		// Print "Current" and "Default" values.
		if (LineTerminator) strcat( TextBuf, LineTerminator );
		if (LinePrefix) strcat( TextBuf, LinePrefix );
		if ( m_Registers[iRegister].WriteOnly )
			sprintf( TextBuf+strlen(TextBuf), "Current=N/A, Default=N/A." );
		else
			sprintf( TextBuf+strlen(TextBuf), "Current=%0*Xh, Default=%0*Xh.", GetRegisterValueFieldWidth(Index,false), GetRegisterValue(Index,false), GetRegisterValueFieldWidth(Index,false), GetRegisterDefaultValue(Index,false) );

		// Print register bit table.
		if (LineTerminator) strcat( TextBuf, LineTerminator );
		if (LinePrefix) strcat( TextBuf, LinePrefix );
		strcat( TextBuf, "+" );
		for ( UInt32 i=0; i<NumCols; i++ )
			strcat( TextBuf, "--------+" );
		for ( int Row=NumRows-1; Row>=0; Row-- )
		{
			if (LineTerminator) strcat( TextBuf, LineTerminator );
			if (LinePrefix) strcat( TextBuf, LinePrefix );
			strcat( TextBuf, (BitfieldWrap?":":"|") );
			strcpy( BottomRow, (BitfieldWrap?":":"|") );
			strcpy( LegendRow, "+" );

			for ( int Col=NumCols-1; Col>=0; Col-- )
			{
				UInt32 Bit = (Row*NumCols) + Col;
				UInt32 BitMask = (0x1 << Bit);
				UInt32 ColOffset = 1;

				for ( i=0; i<m_NumFeatures; i++ )
				{
					if ( !m_Features[i].Overlap && m_Features[i].RegIndex==m_Registers[iRegister].RegIndex && m_Features[i].RegMask!=0xFFFFFFFF && m_Features[i].RegMask&BitMask )
					{
						if ( MatchToCurrentProduct(m_Features[i].Product) && (m_DebugMode || !IsFeatureReserved(m_Features[i].Keyname)) )
						{
							int		LeftBit, RightBit;
							int		TextBufLen, BottomRowLen;
							int		FullCellWidth;
							int		CellGutsWrapPos = 1000;
							int		CellGutsLen;
							char	CellGuts[32];
							#define RowMask(BitsPerRow)		( (BitsPerRow)==8 ? 0x000000FF : (BitsPerRow)==16 ? 0x0000FFFF : 0xFFFFFFFF )

							bitpos32( m_Features[i].RegMask & (RowMask(NumCols)<<(Row*NumCols)), &LeftBit, &RightBit );
							ColOffset = LeftBit - RightBit + 1;
							FullCellWidth = (ColOffset*9) - 1;

							if ( BitfieldWrap )
							{
								// This field has wrapped, so don't reprint the same cell guts on this new row.
								CellGuts[0] = '\0';
								BitfieldWrap = false;
							}
							else
							{
								if ( IsFeatureReserved(m_Features[i].Keyname) )
									strcpy( CellGuts, "RESERVED" );
								else
								{
									strcpy( CellGuts, m_Features[i].Keyname );
									if ( FullCellWidth < (int)strlen(CellGuts) )
										CellGutsWrapPos = m_Features[i].KeynameWrap;
								}
							}
							CellGutsLen = strlen( CellGuts );
							if ( CellGutsLen<CellGutsWrapPos && CellGutsLen>FullCellWidth )
								CellGutsWrapPos = FullCellWidth; // Force a wrap.

							// Test to see if bitfield will wrap
							BitfieldWrap = ( Row>0 && m_Features[i].RegMask&(0x00000001<<((Row*NumCols)-1)) );

							// Print cell guts.
							TextBufLen = strlen( TextBuf );
							BottomRowLen = strlen( BottomRow );
							for ( int i=0; i<FullCellWidth; i++ )
							{
								TextBuf[TextBufLen+i] = ( (i>=CellGutsLen||i>=CellGutsWrapPos) ? ' ' : CellGuts[i] );
								BottomRow[BottomRowLen+i] = ( i>=CellGutsLen-CellGutsWrapPos ? ' ' : CellGuts[CellGutsWrapPos+i] );
							}
							TextBuf[TextBufLen+i] = '\0';
							BottomRow[BottomRowLen+i] = '\0';

							strcat( TextBuf, (BitfieldWrap?":":"|") );
							strcat( BottomRow, (BitfieldWrap?":":"|") );
							break;
						}
					}
				}

				// Is it an empty cell (no features found)?
				if ( i == m_NumFeatures )
				{
					strcat( TextBuf,   "::::::::|" );
					strcat( BottomRow, "::::::::|" );
				}

				// Print cell legend.
				for ( i=0; i<ColOffset; i++ )
				{
					strcat( LegendRow, ((Bit-i)<10?"----":"---") );
					sprintf( LegendRow+strlen(LegendRow), "%d", Bit-i );
					strcat( LegendRow, "---+" );
				}

				// Skip columns if cell is wider than one.
				Col -= (ColOffset - 1);
			}

			if (LineTerminator) strcat( TextBuf, LineTerminator );
			if (LinePrefix) strcat( TextBuf, LinePrefix );
			strcat( TextBuf, BottomRow );
			if (LineTerminator) strcat( TextBuf, LineTerminator );
			if (LinePrefix) strcat( TextBuf, LinePrefix );
			strcat( TextBuf, LegendRow );
		}

		// Print register features.
		for ( i=0; i<m_NumFeatures; i++ )
		{
			if ( m_Features[i].RegIndex==m_Registers[iRegister].RegIndex && m_Features[i].RegMask!=0xFFFFFFFF )
			{
				if ( MatchToCurrentProduct(m_Features[i].Product) && (m_DebugMode || !IsFeatureReserved(m_Features[i].Keyname)) )
				{
					const char*	Suffix = NULL;
					const char* SpanParent = GetFeatureSpanParent( m_Features[i].Keyname, &Suffix );

					if ( SpanParent && Suffix && Suffix[0]!='M' )	// Don't print the span parent unless it is MSB (the last one).
						continue;

					if (LineTerminator) strcat( TextBuf, LineTerminator );
					if (LinePrefix) strcat( TextBuf, LinePrefix );
					if (LineTerminator) strcat( TextBuf, LineTerminator );
					GetFeatureSummary( (SpanParent?SpanParent:m_Features[i].Keyname), TextBuf+strlen(TextBuf), LinePrefix, LineTerminator, true, NumTextCols );
				}
			}
		}
	}

	return TextBuf;
}




UInt32 ChipDefBase::GetRegisterDefaultValue( in UInt32 Index, in bool IsHALIndex )
{
	UInt32 iRegister;

	if ( LookupRegister(Index,IsHALIndex,&iRegister) )
		return m_Registers[iRegister].Default;

	assert( false );	// ERROR: No such register!
	return 0;
}




UInt32 ChipDefBase::GetRegisterValue( in UInt32 Index, in bool IsHALIndex )
{
	UInt32 iRegister;

	if ( m_fHotHotHot )
	{
		if ( LookupRegister(Index,IsHALIndex,&iRegister) )
			return GetRegisterHotValue( m_Registers[iRegister].RegIndex );
		else
			assert( false );		// ERROR: Could not find register! (If IsHALIndex==true, then register is not in the HAL list.)
	}
	else
	{
		if ( !IsHALIndex && !GetRegisterHALIndex(Index,Index) )
		{
			if ( LookupRegister(Index,false,&iRegister) )
				return m_Registers[iRegister].Default;
			else
				assert( false );	// ERROR: No such register!
		}
		return GetRegisterHALValue( Index );
	}

	return 0;
}




bool ChipDefBase::SetRegisterValue( in UInt32 Index, in bool IsHALIndex, in UInt32 Value )
{


	if ( !IsHALIndex && !GetRegisterHALIndex(Index,Index) )
		return false;	// ERROR: No such HAL register!

	SetRegisterHALValue( Index, Value );


	if ( m_fHotHotHot )
	{
		UInt32 iRegister;

		if ( LookupRegister(Index,IsHALIndex,&iRegister) )
		{
			return SetRegisterHotValue( m_Registers[iRegister].RegIndex, Value );
		}
		else
		{
			// ROC TODO: Make sure that assert() s