maresmgr.c

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

	if ( ( dLedMap & MARESMGR_LD_MAP_MASK ) != dLedMap )
	{
		MARESMGR_DBGMSG(("illegal led map\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( pgMaResInfo->dLedMap & dLedMap ) != dLedMap )
	{
		MARESMGR_DBGMSG(("can't free led\n"));
		return MASMW_ERROR;
	}

	pgMaResInfo->dLedMap &= ~dLedMap;

	MARESMGR_DBGMSG((" -> dLedMap=%08lX\n", pgMaResInfo->dLedMap));

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_AllocMotor
 *
 *	Function:
 *			Allocate the specified motor.
 *	Argument:
 *			dMtrMap	bit mapping of motor resources to allocate.
 *	Return:
 *			0		success
 *			< 0		error codes
 *
 ****************************************************************************/
SINT32 MaResMgr_AllocMotor
(
	UINT32	dMtrMap						/* mtr map */
)
{
	MARESMGR_DBGMSG(("    MaResMgr_AllocMotor      : dMtrMap=%08lX", dMtrMap));

	if ( dMtrMap == 0x00000000 ) return MASMW_SUCCESS;

	if ( ( dMtrMap & MARESMGR_MT_MAP_MASK ) != dMtrMap )
	{
		MARESMGR_DBGMSG(("illegal motor map\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( pgMaResInfo->dMtrMap & dMtrMap ) != 0 )
	{
		MARESMGR_DBGMSG(("can't alloc motor\n"));
		return MASMW_ERROR_RESOURCE_OVER;
	}

	pgMaResInfo->dMtrMap |= dMtrMap;

	MARESMGR_DBGMSG((" -> dMtrMap=%08lX\n", pgMaResInfo->dMtrMap));

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_FreeMotor
 *
 *	Function:
 *			Free the specified motor.
 *	Argument:
 *			dMtrMap	bit mapping of motor resources to free.
 *	Return:
 *			0		success
 *			< 0		error codes
 *
 ****************************************************************************/
SINT32 MaResMgr_FreeMotor
(
	UINT32	dMtrMap						/* mtr map */
)
{
	MARESMGR_DBGMSG(("    MaResMgr_FreeMotor       : dMtrMap=%08lX", dMtrMap));

	if ( dMtrMap == 0x00000000 ) return MASMW_SUCCESS;

	if ( ( dMtrMap & MARESMGR_MT_MAP_MASK ) != dMtrMap )
	{
		MARESMGR_DBGMSG(("illegal motor map\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( pgMaResInfo->dMtrMap & dMtrMap ) != dMtrMap )
	{
		MARESMGR_DBGMSG(("can't free motor\n"));
		return MASMW_ERROR;
	}

	pgMaResInfo->dMtrMap &= ~dMtrMap;

	MARESMGR_DBGMSG((" -> dMtrMap=%08lX\n", pgMaResInfo->dMtrMap));

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_AllocSequencer
 *
 *	Function:
 *			Allocate the specified sequencer and setting it.
 *	Argument:
 *			dSeqId		sequencer id
 *			wBaseTime	minimum time base of sequencer
 *	Return:
 *			0		success
 *			< 0		error codes
 *
 ****************************************************************************/
SINT32 MaResMgr_AllocSequencer
(
	UINT32	dSeqId,						/* sequencer id */
	UINT16	wBaseTime					/* base time */
)
{
	UINT32	dSeqMap;

	MARESMGR_DBGMSG(("    MaResMgr_AllocSequencer  : id=%d ", dSeqId));

	dSeqMap = (UINT32)( 1 << dSeqId );
	
	if ( ( dSeqMap & MARESMGR_SQ_MAP_MASK ) != dSeqMap )
	{
		MARESMGR_DBGMSG(("illegal sequencer number\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( pgMaResInfo->dSeqMap & dSeqMap ) != 0 )
	{
		MARESMGR_DBGMSG(("can't alloc sequencer\n"));
		return MASMW_ERROR_RESOURCE_OVER;
	}

	if (wBaseTime > 0xFFFC )
	{
		MARESMGR_DBGMSG(("illegal minimum time base of sequencer\n"));
		return MASMW_ERROR_ARGUMENT;
	}

	pgMaResInfo->dSeqMap |= dSeqMap;

	MARESMGR_DBGMSG(("-> dSeqMap=%08lX\n", pgMaResInfo->dSeqMap));

	if ( dSeqId == 0 )
	{
		MaDevDrv_WriteIntermediateReg( MAI_SEQ_MSS_H, (UINT8)((wBaseTime >> 8) & 0x00FF) );
		MaDevDrv_WriteIntermediateReg( MAI_SEQ_MSS_L, (UINT8)(wBaseTime & 0x00FC) );
		MaDevDrv_WriteIntermediateReg( MAI_SEQ_IRQPOINT, MA_INT_POINT );
		MaDevDrv_WriteIntermediateReg( MAI_SEQ_CTRL, (UINT8)0x02 );
	}

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_FreeSequencer
 *
 *	Function:
 *			Free the specified sequencer.
 *	Argument:
 *			dSeqId	sequencer id
 *	Return:
 *			0		success
 *			< 0		error codes
 *
 ****************************************************************************/
SINT32 MaResMgr_FreeSequencer
(
	UINT32	dSeqId						/* sequencer id */
)
{
	UINT32	dSeqMap;
	
	MARESMGR_DBGMSG(("    MaResMgr_FreeSequencer   : id=%d", dSeqId));

	dSeqMap = (UINT32)( 1 << dSeqId );

	if ( ( dSeqMap & MARESMGR_SQ_MAP_MASK ) != dSeqMap )
	{
		MARESMGR_DBGMSG(("illegal sequencer number\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( pgMaResInfo->dSeqMap & dSeqMap ) != dSeqMap )
	{
		MARESMGR_DBGMSG(("can't free seq\n"));
		return MASMW_ERROR;
	}

	pgMaResInfo->dSeqMap &= ~dSeqMap;

	MARESMGR_DBGMSG((" -> dSeqMap=%08lX\n", pgMaResInfo->dSeqMap));

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_AllocTimer
 *
 *	Function:
 *			Allocate the specified timer.
 *	Arguments:
 *			dTimerId	timer id (0..3)
 *			bBaseTime	base time value (0..127)
 *			bTimeCount		timer count value (0..127)
 *			dMode		0: use base time of timer, 1: use base time of sequencer
 *			dOneShot	0: continuous, 1: one shot
 *	Return:
 *			0		success
 *			< 0		error codes
 *
 ****************************************************************************/
SINT32 MaResMgr_AllocTimer
(
	UINT32	dTimerId,					/* timer id */
	UINT8	bBaseTime,					/* base time */
	UINT8	bTimeCount,					/* timer count value */
	UINT32	dMode,						/* mode */
	UINT32	dOneShot					/* one shot mode */
)
{
	UINT32	dTmMap;
	
	MARESMGR_DBGMSG(("    MaResMgr_AllocTimer      : id=%d bt=%d tm=%d md=%d os=%d", dTimerId, bBaseTime, bTimeCount, dMode, dOneShot));

	if ( dTimerId > 3 )
	{
		MARESMGR_DBGMSG(("illegal timer id\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	if ( dOneShot > 1 )
	{
		MARESMGR_DBGMSG(("illegal mode\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	if ( dMode > 1 )
	{
		MARESMGR_DBGMSG(("illegal one shot mode\n"));
		return MASMW_ERROR_ARGUMENT;
	}

	dTmMap = (UINT32)( 1 << dTimerId );

	if ( ( dTmMap & MARESMGR_TM_MAP_MASK ) != dTmMap )
	{
		MARESMGR_DBGMSG(("illegal timer value\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( pgMaResInfo->dTmMap & dTmMap ) != 0 )
	{
		MARESMGR_DBGMSG(("can't alloc timer\n"));
		return MASMW_ERROR_RESOURCE_OVER;
	}

	if ( pgMaResInfo->dTmMap == 0 )
		MaDevDrv_WriteIntermediateReg( MAI_TIMER_MST, bBaseTime );

	switch ( dTimerId )
	{
	  case 0:  /* Timer#0 */
		MaDevDrv_WriteIntermediateReg( MAI_TIMER0_WR_COUNT, bTimeCount );
		MaDevDrv_WriteIntermediateReg( MAI_TIMER0_CTRL, (UINT8)((dOneShot << 1) | (dMode << 2)) );
		break;
	  case 1:  /* Timer#1 */
		MaDevDrv_WriteIntermediateReg( MAI_TIMER1_WR_COUNT, bTimeCount );
		MaDevDrv_WriteIntermediateReg( MAI_TIMER1_CTRL, (UINT8)((dOneShot << 1) | (dMode << 2)) );
		break;
	  case 2:  /* Timer#2A */
	  case 3:  /* Timer#2B */
		if ( ( pgMaResInfo->dTmMap & 0x000000C0 ) == 0 )
		{
			MaDevDrv_WriteIntermediateReg( MAI_TIMER2_WR_COUNT, bTimeCount );
			MaDevDrv_WriteIntermediateReg( MAI_TIMER2_CTRL, (UINT8)((dOneShot << 1) | (dMode << 2)) );
		}
		break;
	  default:
		return MASMW_ERROR_ARGUMENT;
	}

	pgMaResInfo->dTmMap |= dTmMap;

	MARESMGR_DBGMSG((" -> dTmMap=%08lX\n", pgMaResInfo->dTmMap));

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_FreeTimer
 *
 *	Function:
 *			Free the specified timer of.
 *	Argument:
 *			dTimerId	timer id
 *	Return:
 *			0		success
 *			< 0		error code
 *
 ****************************************************************************/
SINT32 MaResMgr_FreeTimer
(
	UINT32	dTimerId					/* timer id */
)
{
	UINT32	dTmMap;
	
	MARESMGR_DBGMSG(("    MaResMgr_FreeTimer       : id=%d", dTimerId));

	if ( dTimerId > 3 )
	{
		MARESMGR_DBGMSG(("illegal timer id\n"));
		return MASMW_ERROR_ARGUMENT;
	}

	dTmMap = (UINT32)( 1 << dTimerId );

	if ( ( dTmMap & MARESMGR_TM_MAP_MASK ) != dTmMap )
	{
		MARESMGR_DBGMSG(("illegal timer value\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( pgMaResInfo->dTmMap & dTmMap ) != dTmMap )
	{
		MARESMGR_DBGMSG(("can't free timer\n"));
		return MASMW_ERROR;
	}

	switch (dTimerId)
	{
	  case 0:
	  	MaDevDrv_WriteIntermediateReg( MAI_TIMER0_CTRL, 0 );
	  	break;
	  case 1:
	  	MaDevDrv_WriteIntermediateReg( MAI_TIMER1_CTRL, 0 );
	  	break;
	  case 2:
	  	MaDevDrv_WriteIntermediateReg( MAI_TIMER2_TMSTA, 0 );
	  	break;
	  case 3:
	  	MaDevDrv_WriteIntermediateReg( MAI_TIMER2_TMSTB, 0 );
	  	break;
	  default:
	  	return MASMW_ERROR_ARGUMENT;
	}

	pgMaResInfo->dTmMap &= ~dTmMap;

	MARESMGR_DBGMSG((" -> dTmMap=%08lX\n", pgMaResInfo->dTmMap));

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_AllocStreamInt
 *
 *	Function:
 *			Allocate the specified stream interrupt and setting it.
 *	Argument:
 *			dSaiMap		bit mapping of stream interrupt resource to allocate.
 *			bIntPoint	interrupt point.
 *			bBufSize	size of the wave buffer.
 *	Return:
 *			0		success
 *			< 0		error codes
 *
 ****************************************************************************/
SINT32 MaResMgr_AllocStreamInt
(
	UINT32	dSaiMap,					/* stream interrupt map */
	UINT8	bIntPoint,					/* interrupt point */
	UINT8	bBufSize					/* size of the wave buffer */
)
{
	MARESMGR_DBGMSG(("    MaResMgr_AllocStreamInt  : id=%d ", dSaiMap));

	if ( dSaiMap == 0x00000000 ) return MASMW_SUCCESS;
	
	if ( ( dSaiMap & MARESMGR_AI_MAP_MASK ) != dSaiMap )
	{
		MARESMGR_DBGMSG(("illegal stream interrup map\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( pgMaResInfo->dSaiMap & dSaiMap ) != 0 )
	{
		MARESMGR_DBGMSG(("can't alloc sequencer\n"));
		return MASMW_ERROR_RESOURCE_OVER;
	}

	if ( bIntPoint > 3 )
	{
		MARESMGR_DBGMSG(("illegal interrupt point\n"));
		return MASMW_ERROR_ARGUMENT;
	}

	if ( bBufSize > 3 )
	{
		MARESMGR_DBGMSG(("illegal size of the wave buffer\n"));
		return MASMW_ERROR_ARGUMENT;
	}

	if ( pgMaResInfo->dSaiMap == 0 )
	{
		MaDevDrv_WriteIntermediateReg( MAI_STM_IRQ_CTRL, (UINT8)(((bBufSize << 4) | bIntPoint) & 0x33) );
	}

	pgMaResInfo->dSaiMap |= dSaiMap;

	MARESMGR_DBGMSG(("-> dSaiMap=%08lX\n", pgMaResInfo->dSaiMap));

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_FreeStreamInt
 *
 *	Function:
 *			Free the specified stream interrupt.
 *	Argument:
 *			dSaiMap	bit mapping of stream interrupt resource to free.
 *	Return:
 *			0		success
 *			< 0		error codes
 *
 ****************************************************************************/
SINT32 MaResMgr_FreeStreamInt
(
	UINT32	dSaiMap						/* stream interrupt map */
)
{
	MARESMGR_DBGMSG(("    MaResMgr_FreeStreamInt   : id=%d", dSaiMap));

	if ( dSaiMap == 0x00000000 ) return MASMW_SUCCESS;

	if ( ( dSaiMap & MARESMGR_AI_MAP_MASK ) != dSaiMap )
	{
		MARESMGR_DBGMSG(("illegal stream interrupt map\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( pgMaResInfo->dSaiMap & dSaiMap ) != dSaiMap )
	{
		MARESMGR_DBGMSG(("can't free stream interrupt\n"));
		return MASMW_ERROR;
	}

	pgMaResInfo->dSaiMap &= ~dSaiMap;

	MARESMGR_DBGMSG((" -> dSaiMap=%08lX\n", pgMaResInfo->dSaiMap));

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_AllocSoftInt
 *
 *	Function:
 *			Allocate the specified software interrupt.
 *	Argument:
 *			dSiMap	bit mapping of software interrupt resources to allocate.
 *	Return:
 *			0		success
 *			< 0		error code
 *
 ****************************************************************************/
SINT32 MaResMgr_AllocSoftInt
(
	UINT32	dSiMap						/* software interrupt map */
)
{
	MARESMGR_DBGMSG(("    MaResMgr_AllocSoftInt    : dSiMap=%08lX", dSiMap));

	if ( dSiMap == 0x00000000 ) return MASMW_SUCCESS;

	if ( ( dSiMap & MARESMGR_SI_MAP_MASK ) != dSiMap )
	{
		MARESMGR_DBGMSG(("illegal soft int map\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( pgMaResInfo->dSiMap & dSiMap ) != 0 )
	{
		MARESMGR_DBGMSG(("can't alloc soft int\n"));
		return MASMW_ERROR_RESOURCE_OVER;
	}

	pgMaResInfo->dSiMap |= dSiMap;

	MARESMGR_DBGMSG((" -> dSiMap=%08lX\n", pgMaResInfo->dSiMap));

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_FreeSoftInt
 *
 *	Function:
 *			Free the specified software interrupt.
 *			It is possible to specify some software interrupts at once.
 *	Argument:
 *			dSiMap	bit mapping of software interrupt resources to free.
 *	Return:
 *			0		success
 *			< 0		error code
 *
 ****************************************************************************/
SINT32 MaResMgr_FreeSoftInt
(
	UINT32	dSiMap						/* software interrupt map */
)
{
	MARESMGR_DBGMSG(("    MaResMgr_FreeSoftInt     : dSiMap=%08lX", dSiMap));

	if ( dSiMap == 0x00000000 ) return MASMW_SUCCESS;

	if ( ( dSiMap & MARESMGR_SI_MAP_MASK ) != dSiMap )
	{
		MARESMGR_DBGMSG(("illegal soft int map\n"));
		return MASMW_ERROR_ARGUMENT;
	}

	if ( ( pgMaResInfo->dSiMap & dSiMap ) != dSiMap )
	{
		MARESMGR_DBGMSG(("can't free soft int map\n"));
		return MASMW_ERROR;
	}

	pgMaResInfo->dSiMap &= ~dSiMap;

	MARESMGR_DBGMSG((" -> dSiMap=%08lX\n", pgMaResInfo->dSiMap));

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_Initialize
 *
 *	Function:
 *			Initialize the MA Resource Manager.
 *	argument:
 *			None
 *	return:
 *			0		success
 *
 ****************************************************************************/
SINT32 MaResMgr_Initialize( void )
{
	UINT32	dWaveId;
	
	MARESMGR_DBGMSG(("MaResMgr_Initialize\n"));

	/* initialize resource info */
	pgMaResInfo->dRbMap = 0x00000000;		/* RAM block */
	pgMaResInfo->dChMap = 0x00000000;		/* channel */
	pgMaResInfo->dFmMap = 0x00000000;		/* FM voice */
	pgMaResInfo->dWtMap = 0x00000000;		/* WT voice */
	pgMaResInfo->dSaMap = 0x00000000;		/* stream audio */
	pgMaResInfo->dAlMap = 0x00000000;		/* AL voice */
	pgMaResInfo->dHvMap = 0x00000000;		/* HV voice */
	pgMaResInfo->dLedMap = 0x00000000;		/* LED */
	pgMaResInfo->dMtrMap = 0x00000000;		/* motor */
	pgMaResInfo->dSeqMap = 0x00000000;		/* sequencer */
	pgMaResInfo->dTmMap = 0x00000000;		/* timer */
	pgMaResInfo->dSaiMap = 0x00000000;		/* stream interrupt */
	pgMaResInfo->dSiMap = 0x00000000;		/* software interrupt */
	pgMaResInfo->dFmMode = MARESMGR_FMMODE_FREE;	/* FM mode : Free */

	/* reset stream audio info */
	for ( dWaveId = 0; dWaveId < MA_MAX_REG_STREAM_AUDIO; dWaveId++ )
	{
		pgMaResInfo->StreamAudio[dWaveId].dFormat    = (UINT32)0;
		pgMaResInfo->StreamAudio[dWaveId].pbWave     = NULL;
		pgMaResInfo->StreamAudio[dWaveId].dWaveSize  = (UINT32)0;
	}
	
	return MASMW_SUCCESS;
}