hal.c

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

//-----------------------------------------------------------------------------
// COMMON FUNCTION: halWriteDisplay8()
// COMMON FUNCTION: halWriteDisplay16()
// COMMON FUNCTION: halWriteDisplay32()
//-----------------------------------------------------------------------------
void halWriteDisplay8( UInt32 Offset, UInt8 Value, UInt32 Count )
{
	if ( HalInfo.dwFlags & fINDIRECT_SERIAL )
		halpSerWriteDisplay8( Offset, Value, Count );
	else
		halpParWriteDisplay8( Offset, Value, Count );
}

void halWriteDisplay16( UInt32 Offset, UInt16 Value, UInt32 Count )
{
	if ( HalInfo.dwFlags & fINDIRECT_SERIAL )
		halpSerWriteDisplay16( Offset, Value, Count );
	else
		halpParWriteDisplay16( Offset, Value, Count );
}

void halWriteDisplay32( UInt32 Offset, UInt32 Value, UInt32 Count )
{
	if ( HalInfo.dwFlags & fINDIRECT_SERIAL )
		halpSerWriteDisplay32( Offset, Value, Count );
	else
		halpParWriteDisplay32( Offset, Value, Count );
}



//-----------------------------------------------------------------------------
// COMMON FUNCTION: halReadReg8()
// COMMON FUNCTION: halReadReg16()
// COMMON FUNCTION: halReadReg32()
//
//	*** NOTE ***
//	The register access routines do not perform any error checking. This means:
//	 1) NEVER call these routines if halAcquireController() did not succeed.
//	 2) No checks are performed on the Offset to ensure it is a valid register
//		address. It is possible to request a read or write to a non-register
//		offset.
//-----------------------------------------------------------------------------
UInt8 halReadReg8( UInt32 Index )
{
	if ( HalInfo.dwFlags & fINDIRECT_SERIAL )
		return halpSerReadReg8( Index );
	else
		return halpParReadReg8( Index );
}

UInt16 halReadReg16( UInt32 Index )
{
	if ( HalInfo.dwFlags & fINDIRECT_SERIAL )
		return halpSerReadReg16( Index );
	else
		return halpParReadReg16( Index );
}

UInt32 halReadReg32( UInt32 Index )
{
	if ( HalInfo.dwFlags & fINDIRECT_SERIAL )
		return halpSerReadReg32( Index );
	else
		return halpParReadReg32( Index );
}



//-----------------------------------------------------------------------------
// COMMON FUNCTION: halWriteReg8()
// COMMON FUNCTION: halWriteReg16()
// COMMON FUNCTION: halWriteReg32()
//-----------------------------------------------------------------------------
void halWriteReg8( UInt32 Index, UInt8 Value )
{
	if ( HalInfo.dwFlags & fINDIRECT_SERIAL )
		halpSerWriteReg8( Index, Value );
	else
		halpParWriteReg8( Index, Value );

}


void halWriteReg16( UInt32 Index, UInt16 Value )
{
	if ( HalInfo.dwFlags & fINDIRECT_SERIAL )
		halpSerWriteReg16( Index, Value );
	else
		halpParWriteReg16( Index, Value );

}


void halWriteReg32( UInt32 Index, UInt32 Value )
{
	if ( HalInfo.dwFlags & fINDIRECT_SERIAL )
		halpSerWriteReg32( Index, Value );
	else
		halpParWriteReg32( Index, Value );

}



//-----------------------------------------------------------------------------
// COMMON FUNCTION: halModifyReg8()
// COMMON FUNCTION: halModifyReg16()
// COMMON FUNCTION: halModifyReg32()
//-----------------------------------------------------------------------------
UInt8 halModifyReg8( UInt32 Index, UInt32 AndMask, UInt32 OrMask )
{
	UInt8 Value = (UInt8)((halReadReg8(Index) & ~AndMask) | OrMask);
	halWriteReg8( Index, Value );
	return Value;
}

UInt16 halModifyReg16( UInt32 Index, UInt32 AndMask, UInt32 OrMask )
{
	UInt16 Value = (UInt16)((halReadReg16(Index) & ~AndMask) | OrMask);
	halWriteReg16( Index, Value );
	return Value;
}

UInt32 halModifyReg32( UInt32 Index, UInt32 AndMask, UInt32 OrMask )
{
	UInt32 Value = ((halReadReg32(Index) & ~AndMask) | OrMask);
	halWriteReg32( Index, Value );
	return Value;
}



//-----------------------------------------------------------------------------
// COMMON FUNCTION: halReadData()
// COMMON FUNCTION: halWriteData()
//-----------------------------------------------------------------------------
void halReadData( int AccessSize, UInt32 Offset, void* pData, UInt32 nBytes )
{
	if ( !AccessSize )
		AccessSize = HAL_REGBYTES;

	if ( HalInfo.dwFlags & fINDIRECT_SERIAL )
		halpSerReadData( AccessSize, Offset, pData, nBytes/AccessSize );
	else
		halpParReadData( AccessSize, Offset, pData, nBytes/AccessSize );
}

void halWriteData( int AccessSize, UInt32 Offset, const void* pData, UInt32 nBytes )
{
	if ( !AccessSize )
		AccessSize = HAL_REGBYTES;

	if ( HalInfo.dwFlags & fINDIRECT_SERIAL )
		halpSerWriteData( AccessSize, Offset, pData, nBytes/AccessSize );
	else
		halpParWriteData( AccessSize, Offset, pData, nBytes/AccessSize );
}




//----------------------------------------------------------------------------
// COMMON FUNCTION: halDelayUS - Delay for the specified number of microseconds.
//
// This function can be used to delay for short times.
//----------------------------------------------------------------------------
Boolean halDelayUS( UInt32 microseconds )
{
	int i;
	for( i = 0; i < microseconds; i++ )		// 1s at 40MHz main clk and 20MHz bus clk wait 1 cycle
	{
		asm(" nop ");
		asm(" nop ");
		asm(" nop ");
		asm(" nop ");
		asm(" nop ");
		asm(" nop ");
	}
	return TRUE;
}




//===========================================================================
// PRIVATE (STATIC) FUNCTIONS (local to HAL only)
//===========================================================================



//---------------------------------------------------------------------------
// PRIVATE FUNCTION: InitRegisters()
//---------------------------------------------------------------------------
static void InitRegisters( void )
{
	int idx;
	UInt32 reg;

	for (idx = 0; HalInfo.Regs[idx].Index != REGFLAG_ENDOFTABLE; idx++)
	{
		reg = HalInfo.Regs[idx].Index;

		if (reg < REGFLAG_BASE)
		{
			HAL_WRITE_REG(reg, (UInt8)HalInfo.Regs[idx].Value);
		}
		else if (reg == REGFLAG_DELAY || reg == REGFLAG_OFFDELAY || reg == REGFLAG_ONDELAY)
		{
			halDelayUS(HalInfo.Regs[idx].Value * 1000UL);
		}
	}
}


//---------------------------------------------------------------------------
//	PRIVATE FUNCTION: ProgramParallelPanels()
//
//	DESCRIPTION:
//---------------------------------------------------------------------------
static void ProgramParallelPanels( void )
{
	int Panel;
	UInt32 *pLCDRegs;
	UIntReg Reg003C = HAL_READ_REG(REG003C_LCDXFER);
	UIntReg Reg004C = HAL_READ_REG(REG004C_DISPSETTING);

	// Auto frame transfer must be disabled before accessing the LCD interface registers.
	HAL_WRITE_REG(REG003C_LCDXFER, 0);

	Panel = 1;				// LCD panel 1 or 2
	do
	{
		pLCDRegs = (Panel==1) ? HalInfo.LCD1Regs : (Panel==2) ? HalInfo.LCD2Regs : HalInfo.LCD3Regs;

		if ( *pLCDRegs == HAL_LCD_ENDOFTABLE )
			continue;

		// Select the appropriate LCD Output Port
		HAL_WRITE_REG(REG004C_DISPSETTING, (UIntReg)((HAL_READ_REG(REG004C_DISPSETTING) & ~3) | Panel));

		// *** Don't try to write to the command/data registers when the LCD interface is busy
		while ( *pLCDRegs != HAL_LCD_ENDOFTABLE )
		{
			UInt32 Value = (*pLCDRegs & HAL_LCD_DATAMASK);

			switch ( (*pLCDRegs & HAL_LCD_FLAGMASK) )
			{
			case HAL_LCD_COMMAND:
				while ((HAL_READ_REG(REG0038_LCDSTATUS) & 0x01))
					continue;
				HAL_WRITE_REG(REG0030_LCDCMD0, LOBYTE(Value));
				HAL_WRITE_REG(REG0031_LCDCMD1, HIBYTE(Value));
				break;

			case HAL_LCD_PARAM:
				while ((HAL_READ_REG(REG0038_LCDSTATUS) & 0x01))
					continue;
				HAL_WRITE_REG(REG0032_LCDWRITE0, LOBYTE(Value));
				HAL_WRITE_REG(REG0033_LCDWRITE1, HIBYTE(Value));
				break;

			  case HAL_LCD_DELAY:
				halDelayUS( Value * 1000UL );
				break;

			  default:
				break;
			}

			pLCDRegs++;
		};

	} while ( ++Panel <= 3 );

	// Restore the selected display panel and transfer mode.
	HAL_WRITE_REG(REG004C_DISPSETTING, Reg004C);
	HAL_WRITE_REG(REG003C_LCDXFER, Reg003C);
}


//---------------------------------------------------------------------------
// PRIVATE FUNCTION: ClearVideoMemory()
//---------------------------------------------------------------------------
static void ClearVideoMemory( void )
{
	UInt32 MemSize = HAL_READ_REG(REG0001_PRODINFO1) * 4096UL;

	halWriteDisplay32( 0, 0, MemSize/sizeof(UInt32) );
	halWriteReg8( REG003A_LCDFRAMEXFER, 1 );

}


void halSetProcessExclusivity( Boolean fExclusive )
{

}