hal.c

是一个手机功能的模拟程序

// COMMON FUNCTION: halWriteDisplay16()
// COMMON FUNCTION: halWriteDisplay32()
//-----------------------------------------------------------------------------
void halWriteDisplay8( UInt32 Offset, UInt8 Value, UInt32 Count )
{
	halpParWriteDisplay8( Offset, Value, Count );
}

void halWriteDisplay16( UInt32 Offset, UInt16 Value, UInt32 Count )
{
	halpParWriteDisplay16( Offset, Value, Count );
}

void halWriteDisplay32( UInt32 Offset, UInt32 Value, UInt32 Count )
{
	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 )
{
	UInt8 Data;
	Data = halpParReadReg8( Index );
	return Data;
}


UInt16 halReadReg16( UInt32 Index )
{
	UInt8 Data;
	Data=halpParReadReg16( Index );
	return Data;
}

UInt32 halReadReg32( UInt32 Index )
{
	UInt8 Data;
	Data=halpParReadReg32( Index );
	return Data; 
}



//-----------------------------------------------------------------------------
// COMMON FUNCTION: halWriteReg8()
// COMMON FUNCTION: halWriteReg16()
// COMMON FUNCTION: halWriteReg32()
//-----------------------------------------------------------------------------
void halWriteReg8( UInt32 Index, UInt8 Value )
{
	halpParWriteReg8( Index, Value );
}


void halWriteReg16( UInt32 Index, UInt16 Value )
{
	halpParWriteReg16( Index, Value );
}


void halWriteReg32( UInt32 Index, UInt32 Value )
{
	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;
}

#if 0
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;
}
#endif


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

	halpParReadData( AccessSize, Offset, pData, nBytes/AccessSize );
}

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

	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 )
{
#if 0
	CAMERA_TR(CAM_TR_MASK_HAL, ("halDelayUS(%d)", microseconds));
	
	if(microseconds > 5000)
		rvf_delay(RVF_MS_TO_TICKS(microseconds/1000));
	else
		wait_ARM_cycles(convert_nanosec_to_cycles(microseconds * 1000));
	
	return TRUE;
#else
	UINT32 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 ");
		asm(" nop ");
		asm(" nop ");
		asm(" nop ");
		asm(" nop ");
		asm(" nop ");
		asm(" nop ");
	}
	return TRUE;

//	volatile unsigned short a;

//    	while (microseconds-- > 0) for (a=0;a<5;a++) asm(" nop");

//	return TRUE;
#endif
}

void halDelayUS_forInit( UInt32 microseconds )
{
	UINT32 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 ");
		asm(" nop ");
		asm(" nop ");
		asm(" nop ");
		asm(" nop ");
		asm(" nop ");
		asm(" nop ");
	}

}



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



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

	for (idx = 0; HalInfo.Regs[idx].Index != REGFLAG_ENDOFTABLE; idx++)
	{
		reg = HalInfo.Regs[idx].Index;
		
		if (reg < REGFLAG_BASE)
		{
			//reg1=HAL_READ_REG(reg);
			//MI_dbgPrintf("1reg%x=%x",reg,reg1);
			//halDelayUS(1000);
			HAL_WRITE_REG(reg, (UInt8)HalInfo.Regs[idx].Value);
			//reg2=HAL_READ_REG(reg);
			//MI_dbgPrintf("2reg%x=%x",reg,reg2);
			//halDelayUS(1000);
		}
		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 )
{

}