mamachdep.c

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

/****************************************************************************
 *
 *		Copyright (C) 2002-2003	YAMAHA CORPORATION. All rights reserved.
 *
 *		Module		: mamachdep.c
 *
 *		Description	: machine dependent part for MA SMW
 *
 *
 *		Version		: 2.0.8 	2003.06.26
 *
 *
 ****************************************************************************/

#include "typedefs.h"
#include "rvf_api.h"	/* 2003/10/21	 Robert.Chen
						 * Use Reviera Frame API to implement machine depend
						 * functions, e.g. machdep_sleep()
						 */
#include "melody_cfg.h"


#include "mamachdep.h"
#include "madevdrv.h"
#include "madefs.h"

UINT32 gdPrevAccessType;

/* H/W access wait table */
static const UINT32 WriteWait[2] = { 230, 70 };		/* Write-Write/Read-Write */
static const UINT32 ReadWait[2]  = { 550, 70 };		/* Write-Read /Read-Read  */


extern void wait_ARM_cycles(UINT32 cpt_loop);
extern inline UINT32 convert_nanosec_to_cycles(UINT32 time);
extern void MI_dbgPrintf(const char * const format,...);
/****************************************************************************
 *	machdep_memcpy
 *
 *	Function:
 *			Copy memory
 *	Arguments:
 *			pDst		Destination
 *			pSrc		Source
 *			dSize		Copy Size(Bytes)
 *	Return:
 *			None
 *
 ****************************************************************************/
void machdep_memcpy( UINT8 *pDst, UINT8 *pSrc, UINT32 dSize )
{
	while ( dSize-- != 0 )
	{
		*pDst++ = *pSrc++;
	}
}
/****************************************************************************
 *	machdep_ErrHandler
 *
 *	Function:
 *			Low Level Error handler
 *	Arguments:
 *			dError	error code
 *	Return:
 *			None
 *
 ****************************************************************************/
void machdep_ErrHandler( SINT32 sdError )
{
	/*----------------------------------------------------------------------*
	 *----------------------------------------------------------------------*/
	MI_dbgPrintf("MelDevDrv:Error!!! %d", sdError);
}
/****************************************************************************
 *	machdep_Wait
 *
 *	Function:
 *			wait.
 *	Arguments:
			dWaitTime	wait time[ns]
 *	Return:
 *			None
 *
 ****************************************************************************/
void machdep_Wait( UINT32 dWaitTime )
{
	/*----------------------------------------------------------------------*
	 *----------------------------------------------------------------------*/

	wait_ARM_cycles(convert_nanosec_to_cycles(dWaitTime+20));
}
/****************************************************************************
 *	machdep_WriteStatusFlagReg
 *
 *	Function:
 *			Write a byte data to the status flag register.
 *	Arguments:
 *			bData	byte data for write
 *	Return:
 *			None
 *
 ****************************************************************************/
void machdep_WriteStatusFlagReg( UINT8	bData )
{
	/* HW access wait */
	machdep_Wait( WriteWait[gdPrevAccessType] );
	gdPrevAccessType = MADEVDRV_ACCESS_WRITE;

	/*----------------------------------------------------------------------*
	 *----------------------------------------------------------------------*/

	MA_STATUS_REG = bData;

}
/****************************************************************************
 *	machdep_ReadStausFlagReg
 *
 *	Function:
 *			Read a byte data from the status flag register.
 *	Arguments:
 *			None
 *	Return:
 *			status register value
 *
 ****************************************************************************/
UINT8 machdep_ReadStatusFlagReg( void )
{
	UINT8	bData;

	/* HW access wait */
	machdep_Wait( ReadWait[gdPrevAccessType] );
	gdPrevAccessType = MADEVDRV_ACCESS_READ;


	/*----------------------------------------------------------------------*
	 *----------------------------------------------------------------------*/

	bData = MA_STATUS_REG;

	return bData;
}
/****************************************************************************
 *	machdep_WriteDataReg
 *
 *	Function:
 *			Write a byte data to the data register.
 *	Arguments:
			bData	byte data for write
 *	Return:
 *			None
 *
 ****************************************************************************/
void machdep_WriteDataReg( UINT8 bData )
{
	/* HW access wait */
	machdep_Wait( WriteWait[gdPrevAccessType] );
	gdPrevAccessType = MADEVDRV_ACCESS_WRITE;

	/*----------------------------------------------------------------------*
	 *----------------------------------------------------------------------*/

	MA_DATA_REG = bData;

}
/****************************************************************************
 *	machdep_WriteDataRegN
 *
 *	Function:
 *			Write N byte data to the data register.
 *	Arguments:
 *			pbData	data pointer
 *			dSize	data size
 *	Return:
 *			None
 *
 ****************************************************************************/
void machdep_WriteDataRegN( UINT8* pbData, UINT32 dSize )
{
	UINT32 i;

	if( dSize==0 ) return;

	/* HW access wait */
	machdep_Wait( WriteWait[gdPrevAccessType] );
	gdPrevAccessType = MADEVDRV_ACCESS_WRITE;

	i = dSize;
	while( (i--)!=0 )
	{
	/*----------------------------------------------------------------------*
	 *----------------------------------------------------------------------*/

		MA_DATA_REG = *pbData++;
		machdep_Wait( 230 );
	}
}
/****************************************************************************
 *	machdep_WriteDataRegValN
 *
 *	Function:
 *			Write data to the data register.
 *	Arguments:
 *			bVal	value
 *			dSize	data size
 *	Return:
 *			None
 *
 ****************************************************************************/
void machdep_WriteDataRegValN( UINT8 bVal, UINT32 dSize )
{
	UINT32 i;

	if( dSize==0 ) return;

	/* HW access wait */
	machdep_Wait( WriteWait[gdPrevAccessType] );
	gdPrevAccessType = MADEVDRV_ACCESS_WRITE;

	i = dSize;
	while( (i--)!=0 )
	{
	/*----------------------------------------------------------------------*
	 *----------------------------------------------------------------------*/

		MA_DATA_REG = bVal;
		machdep_Wait( 230 );
	}
}
/****************************************************************************
 * machdep_ReadDataReg
 *
 *	Function:
 *			Read a byte data from the data register.
 *	Arguments:
			None
 *	Return:
 *			read data
 *
 ****************************************************************************/
UINT8 machdep_ReadDataReg( void )
{
	UINT8	bData;

	/* HW access wait */
	machdep_Wait( ReadWait[gdPrevAccessType] );
	gdPrevAccessType = MADEVDRV_ACCESS_READ;

	/*----------------------------------------------------------------------*
	 *----------------------------------------------------------------------*/

	bData = MA_DATA_REG;

	return bData;
}
/****************************************************************************
 *	machdep_WaitValidData
 *
 *	Function:
 *			Check status of MA-5.
 *	Arguments:
			flag	check flag
 *	Return:
 *			0		success
 *			-5		time out
 *
 ****************************************************************************/
SINT32 machdep_WaitValidData( UINT8 bFlag )
{
	UINT8	bStatus;
	volatile UINT32 time = 0;

	do
	{
		bStatus = machdep_ReadStatusFlagReg();

		if ( time++ > MA_STATUS_TIMEOUT )
		{
			/* error handler */
			machdep_ErrHandler(MASMW_ERROR_TIMEOUT);
			/* timeout: stop timer */
			return MASMW_ERROR_TIMEOUT;
		}
	}
	while ( ( bStatus & bFlag ) == 0 );

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	machdep_Sleep
 *
 *
 ****************************************************************************/
void machdep_Sleep( UINT32 dSleepTime )
{
	rvf_delay(RVF_MS_TO_TICKS(dSleepTime));
}
/****************************************************************************
 *	machdep_CheckDelayedFifoEmpty
 *
 *	Function:
 *			Check Delayed FIFO Empty Flag
 *	Arguments:
			
 *	Return:
 *			0		not Empty
 *			1		Empty
 *
 ****************************************************************************/
SINT32 machdep_CheckDelayedFifoEmpty( void )
{
	UINT8 bStatus;

	bStatus = machdep_ReadStatusFlagReg();

	if( (bStatus&MAB_STAT_EMP_DW)!=0 )
		return 1;
	else
		return 0;
}
/****************************************************************************
 *	machdep_WaitDelayedFifoEmpty
 *
 *	Function:
 *			Wait untill Delayed FIFO Empty
 *	Arguments:
			
 *	Return:
 *			0		success
 *			-5		time out
 *
 ****************************************************************************/
SINT32 machdep_WaitDelayedFifoEmpty( void )
{
	UINT32 bStatus;
	volatile UINT16 time = 0;

	do
	{
		bStatus = machdep_ReadStatusFlagReg();

		if ( time++ > MA_STATUS_TIMEOUT )
		{
			/* error handler */
			machdep_ErrHandler(MASMW_ERROR_TIMEOUT);
			/* timeout: stop timer */
			return MASMW_ERROR_TIMEOUT;
		}
	} while( (bStatus&MAB_STAT_EMP_DW)==0 );

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	machdep_WaitImmediateFifoEmpty
 *
 *	Function:
 *			Wait untill Immediate FIFO Empty
 *	Arguments:
			
 *	Return:
 *			0		success
 *			-5		time out
 *
 ****************************************************************************/
SINT32 machdep_WaitImmediateFifoEmpty( void )
{
	UINT8 bStatus;
	volatile UINT16 time = 0;
	
	do 
	{
		bStatus = machdep_ReadStatusFlagReg();

		if ( time++ > MA_STATUS_TIMEOUT )
		{
			/* error handler */
			machdep_ErrHandler(MASMW_ERROR_TIMEOUT);
			/* timeout: stop timer */
			return MASMW_ERROR_TIMEOUT;
		}
	} while( (bStatus&MAB_STAT_EMP_W)==0 );

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	machdep_GenerateIrqProcTask
 *
 *	Description:
 *			
 *	Argument:
 *			dIrqFlag
 *			dOldSetting
 *	Return:
 *			None
 *
 ****************************************************************************/
void machdep_GenerateIrqProcTask( UINT32 dIrqFlag, UINT8 bOldSetting )
{
	MaDevDrv_IrqProc( dIrqFlag, bOldSetting );
}
/****************************************************************************
 *	machdep_PowerManagement
 *
 *	Description:
 *			Power management.
 *	Argument:
 *			bMode	0: Hardware initialize sequence (normal)
 *					1: Power down change sequence
 *					2: Power down release sequence
 *	Return:
 *			0		success
 *			< 0		error code
 *
 ****************************************************************************/
SINT32 machdep_PowerManagement( UINT8 bMode )
{
	SINT32	sdResult;
	UINT32	dCount;
#if (MA_DEVICETYPE == MASMW_DEVICETYPE_MA5I)
	UINT8	bRegData;
#endif
	volatile UINT16 timeout = 0;

	sdResult= MASMW_SUCCESS;

	switch ( bMode )
	{
	case 0:

		/* sequence of hardware initialize when normal */

		/* set BANK bits of REG_ID #4 basic setting register to '0' */
		machdep_WriteStatusFlagReg( MAI_BASIC_SETTING );
		machdep_WriteDataReg( 0x00 );

		/* set DP0 bit of REG_ID #5 power management (D) setting register to '0' */
		machdep_WriteStatusFlagReg( MAI_POWER_MANAGEMENT_DIGITAL );
		machdep_WriteDataReg( MAB_PWM_DP3 | MAB_PWM_DP2 | MAB_PWM_DP1 );

		/* wait 2ms */
		machdep_Wait( 2 * 1000 * 1000 );

		/* set PLLPD and AP0 bits of REG_ID #6 power management (A) setting register to '0' */
		machdep_WriteStatusFlagReg( MAI_POWER_MANAGEMENT_ANALOG );
#if (MA_DEVICETYPE != MASMW_DEVICETYPE_MA5I)
		/* MA-5 or MA-5S */
		machdep_WriteDataReg( MAB_PWM_AP4R | MAB_PWM_AP4L | MAB_PWM_AP3 |
														MAB_PWM_AP2 | MAB_PWM_AP1 );
#else
		/* MA-5i */
		machdep_WriteDataReg( MAB_PWM_AP4L | MAB_PWM_AP3 |
														MAB_PWM_AP2 | MAB_PWM_AP1 );
#endif

		/* wait 10ms */
		machdep_Wait( 10 * 1000 * 1000 );

#if (MA_DEVICETYPE == MASMW_DEVICETYPE_MA5I)
		/* check VREF_RDY bit of Bank #3 REG_ID #37 */
		
		/* set BANK bits of REG_ID #4 basic setting register to '3' */