maresmgr.c

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

 *	Function:
 *			Allocate the specified LED.
 *	Argument:
 *			ld_map	bit mapping of LED resources to allocate.
 *	Return:
 *			0		success
 *			< 0		error codes
 *
 ****************************************************************************/
SINT32 MaResMgr_AllocLed
(
	UINT32	ld_map						/* led map */
)
{
	MARESMGR_DBGMSG(("    MaResMgr_AllocLed        : ld_map=%08lX", ld_map));

	if ( ( ld_map & MA_LD_MAP_MASK ) != ld_map )
	{
		MARESMGR_DBGMSG(("illegal led number\n"));
		return MASMW_ERROR_ARGUMENT;
	}

	if ( ( ma_resource_info.ld_map & ld_map ) != 0 )
	{
		MARESMGR_DBGMSG(("can't alloc led\n"));
		return MASMW_ERROR_RESOURCE_OVER;
	}

	ma_resource_info.ld_map |= ld_map;

	MARESMGR_DBGMSG((" -> ld_map=%08lX\n", ma_resource_info.ld_map));

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

	if ( ( ld_map & MA_LD_MAP_MASK ) != ld_map )
	{
		MARESMGR_DBGMSG(("illegal led number\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( ma_resource_info.ld_map & ld_map ) != ld_map )
	{
		MARESMGR_DBGMSG(("can't free led\n"));
		return MASMW_ERROR;
	}

	ma_resource_info.ld_map ^= ld_map;

	MARESMGR_DBGMSG((" -> ld_map=%08lX\n", ma_resource_info.ld_map));

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

	if ( ( mt_map & MA_MT_MAP_MASK ) != mt_map )
	{
		MARESMGR_DBGMSG(("illegal motor number\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( ma_resource_info.mt_map & mt_map ) != 0 )
	{
		MARESMGR_DBGMSG(("can't alloc motor\n"));
		return MASMW_ERROR_RESOURCE_OVER;
	}

	ma_resource_info.mt_map |= mt_map;

	MARESMGR_DBGMSG((" -> mt_map=%08lX\n", ma_resource_info.mt_map));

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

	if ( ( mt_map & MA_MT_MAP_MASK ) != mt_map )
	{
		MARESMGR_DBGMSG(("illegal motor number\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( ma_resource_info.mt_map & mt_map ) != mt_map )
	{
		MARESMGR_DBGMSG(("can't free mtr\n"));
		return MASMW_ERROR;
	}

	ma_resource_info.mt_map ^= mt_map;

	MARESMGR_DBGMSG((" -> mt_map=%08lX\n", ma_resource_info.mt_map));

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_AllocTimer
 *
 *	Function:
 *			Allocate the specified timer of.
 *	Arguments:
 *			timer_id	timer id (0..2)
 *			base_time	base time value (0..127)
 *			time		timer count value (0..127)
 *			mode		
 *			one_shot	0: continuous, 1: one shot
 *	Return:
 *			0		success
 *			< 0		error codes
 *
 ****************************************************************************/
SINT32 MaResMgr_AllocTimer
(
	UINT8	timer_id,					/* timer id */
	UINT8	base_time,					/* base time */
	UINT8	time_count,					/* timer count value */
	UINT8	mode,						/* mode */
	UINT8	one_shot					/* one shot mode */
)
{
	UINT8	packet[7];
	UINT8	num = 0;
	UINT8	sw;
	UINT32	tm_map;
	SINT32	result;
	
	MARESMGR_DBGMSG(("    MaResMgr_AllocTimer      : id=%d bt=%d tm=%d md=%d os=%d", timer_id, base_time, time_count, mode, one_shot));

	if ( timer_id > 3 ) return MASMW_ERROR_ARGUMENT;
	if ( one_shot > 1 ) return MASMW_ERROR_ARGUMENT;
	if ( mode > 1 ) 	return MASMW_ERROR_ARGUMENT;

	tm_map = (UINT32)( 1 << timer_id );

	if ( ( tm_map & MA_TM_MAP_MASK ) != tm_map )
	{
		MARESMGR_DBGMSG(("illegal timer value\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( ma_resource_info.tm_map & tm_map ) != 0 )
	{
		MARESMGR_DBGMSG(("can't alloc timer\n"));
		return MASMW_ERROR_RESOURCE_OVER;
	}

	if ( timer_id < 2 )						/* Timer #0 */
	{
		if ( ( ma_resource_info.tm_map & 0x03 ) == 0 )
		{
			packet[num++] = (UINT8)(  MA_TIMER_MS           & 0x7F );	/* address */
			packet[num++] = (UINT8)( (MA_TIMER_MS >> 7)     | 0x80 );
			packet[num++] = (UINT8)(  base_time             | 0x80 );	/* data */

			packet[num++] = (UINT8)(  MA_TIMER_0_TIME       & 0x7F );	/* address */
			packet[num++] = (UINT8)( (MA_TIMER_0_TIME >> 7) | 0x80 );
			packet[num++] = (UINT8)(  time_count            & 0x7F );	/* data */
			packet[num++] = (UINT8)( (one_shot << 1) | (mode << 2) | 0x80 );

			result = MaDevDrv_SendDirectPacket( packet, num );
		}
		else
		{
			result = MASMW_SUCCESS;
		}
	}
	else									/* Timer #1 */
	{
		sw = (UINT8)( ( mode == 1 ) ? 1 : 0 );

		packet[num++] = (UINT8)(  MA_TIMER_1_TIME		& 0x7F );	/* address */
		packet[num++] = (UINT8)( (MA_TIMER_1_TIME >> 7) | 0x80 );
		packet[num++] = (UINT8)(  time_count            & 0x7F );	/* data */
		packet[num++] = (UINT8)( (one_shot << 1) | (mode << 2) | sw | 0x80 );

		result = MaDevDrv_SendDirectPacket( packet, num );
	}

	if (result >= 0)
		ma_resource_info.tm_map |= tm_map;

	MARESMGR_DBGMSG((" -> tm_map=%08lX\n", ma_resource_info.tm_map));

	return result;
}
/****************************************************************************
 *	MaResMgr_FreeTimer
 *
 *	Function:
 *			Free the specified timer of.
 *	Argument:
 *			timer_id	timer id
 *	Return:
 *			0		success
 *			< 0		error code
 *
 ****************************************************************************/
SINT32 MaResMgr_FreeTimer
(
	UINT8	timer_id					/* timer id */
)
{
	UINT8	packet[3];
	UINT32	tm_map;
	SINT32	result = MASMW_SUCCESS;
	
	MARESMGR_DBGMSG(("    MaResMgr_FreeTimer       : id=%d", timer_id));

	if ( timer_id > 2 ) return MASMW_ERROR_ARGUMENT;

	tm_map = (UINT32)( 1 << timer_id );

	if ( ( tm_map & MA_TM_MAP_MASK ) != tm_map )
	{
		MARESMGR_DBGMSG(("illegal timer value\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( ma_resource_info.tm_map & tm_map ) != tm_map )
	{
		MARESMGR_DBGMSG(("can't free timer map\n"));
		return MASMW_ERROR;
	}

	ma_resource_info.tm_map ^= tm_map;

	MARESMGR_DBGMSG((" -> tm_map=%08lX\n", ma_resource_info.tm_map));

	if ( timer_id == 2 )					/* Timer #1 */
	{
		packet[0] = (UINT8)(  MA_TIMER_1_CTRL		& 0x7F );	/* address */
		packet[1] = (UINT8)( (MA_TIMER_1_CTRL >> 7) | 0x80 );
		packet[2] = (UINT8)(                          0x80 );	/* data */

		result = MaDevDrv_SendDirectPacket( packet, 3 );
	}

	return result;
}
/****************************************************************************
 *	MaResMgr_AllocSequencer
 *
 *	Function:
 *			Allocate the specified sequencer and setting it.
 *	Argument:
 *			seq_id		sequencer id
 *			base_time	minimum time base of sequencer
 *	Return:
 *			0		success
 *			< 0		error codes
 *
 ****************************************************************************/
SINT32 MaResMgr_AllocSequencer
(
	UINT8	seq_id,						/* sequencer id */
	UINT16	base_time					/* base time */
)
{
	UINT8	packet[5];
	UINT32	sq_map;
	SINT32	result;

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

	sq_map = (UINT32)( 1 << seq_id );

	if ( ( sq_map & MA_SQ_MAP_MASK ) != sq_map )
	{
		MARESMGR_DBGMSG(("illegal sequencer number\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( ma_resource_info.sq_map & sq_map ) != 0 )
	{
		MARESMGR_DBGMSG(("can't alloc sequencer\n"));
		return MASMW_ERROR_RESOURCE_OVER;
	}

	ma_resource_info.sq_map |= sq_map;

	MARESMGR_DBGMSG(("-> sq_map=%08lX\n", ma_resource_info.sq_map));

	if ( seq_id == 0 )
	{
		packet[0] = (UINT8)(  MA_SEQUENCE       & 0x7F );	/* address */
		packet[1] = (UINT8)( (MA_SEQUENCE >> 7) | 0x80 );
		packet[2] = (UINT8)( (base_time   >> 7) & 0x7F );	/* data */
		packet[3] = (UINT8)(  base_time         & 0x7F );
		packet[4] = (UINT8)(  MA_INT_POINT      | 0x80 );
		result = MaDevDrv_SendDirectPacket( packet, 5 );
	}
	else
	{
		result = MASMW_SUCCESS;
	}

	if (result < 0)
		ma_resource_info.sq_map ^= sq_map;

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

	sq_map = (UINT32)( 1 << seq_id );

	if ( ( sq_map & MA_SQ_MAP_MASK ) != sq_map )
	{
		MARESMGR_DBGMSG(("illegal sequencer number\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( ma_resource_info.sq_map & sq_map ) != sq_map )
	{
		MARESMGR_DBGMSG(("can't free seq\n"));
		return MASMW_ERROR;
	}

	ma_resource_info.sq_map ^= sq_map;

	MARESMGR_DBGMSG((" -> sq_map=%08lX\n", ma_resource_info.sq_map));

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

	ma_resource_info.ch_map = 0x00000000;		/* channel */
	ma_resource_info.fm_map = 0x00000000;		/* FM voice */
	ma_resource_info.wt_map = 0x00000000;		/* WT voice */
	ma_resource_info.tm_map = 0x00000000;		/* timer */
	ma_resource_info.si_map = 0x00000000;		/* software interrupt */
	ma_resource_info.rb_map = 0x00000000;		/* RAM block */
	ma_resource_info.sa_map = 0x00000000;		/* stream audio */
	ma_resource_info.ld_map = 0x00000000;		/* LED */
	ma_resource_info.mt_map = 0x00000000;		/* motor */
	ma_resource_info.sq_map = 0x00000000;		/* sequencer */

	/* reset stream audio info */
	for ( wave_id = 0; wave_id < MA_MAX_REG_STREAM_AUDIO; wave_id++ )
	{
		ma_resource_info.stream_audio[wave_id].format    = (UINT8)0;
		ma_resource_info.stream_audio[wave_id].wave_ptr  = NULL;
		ma_resource_info.stream_audio[wave_id].wave_size = (UINT32)0;
		ma_resource_info.stream_audio[wave_id].seek_pos  = (UINT32)0;
	}
	
	return MASMW_SUCCESS;
}