maresmgr.c

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

 *	Return:
 *			0		success
 *			< 0		error codes
 *
 ****************************************************************************/
SINT32 MaResMgr_AllocFmVoice
(
	UINT32	dFmMap,						/* FM voice map */
	UINT32	dFmMode						/* FM mode */
)
{
	UINT8	bMaiMode;
	
	MARESMGR_DBGMSG(("    MaResMgr_AllocFmVoice    : dFmMap=%08lX", dFmMap));

	if ( dFmMap == 0x00000000 ) return MASMW_SUCCESS;

	if ( ( dFmMap & MARESMGR_FM_MAP_MASK ) != dFmMap )
	{
		MARESMGR_DBGMSG(("illegal fm voice value\n"));
		return MASMW_ERROR_ARGUMENT;
	}

	if ( dFmMode == MARESMGR_FMMODE_4OP )
	{	/* 4OP */
		if ( ( dFmMap & MA_FM_EXT_MAP_MASK ) != 0 )
		{
			MARESMGR_DBGMSG(("illegal fm mode\n"));
			return MASMW_ERROR_ARGUMENT;
		}
	}
	else if ( dFmMode > MARESMGR_FMMODE_4OP )
	{
		MARESMGR_DBGMSG(("illegal fm mode\n"));
		return MASMW_ERROR_ARGUMENT;
	}

	if ( ( pgMaResInfo->dFmMap & dFmMap ) != 0 )
	{
		MARESMGR_DBGMSG(("can't alloc fm voice\n"));
		return MASMW_ERROR_RESOURCE_OVER;
	}
	
	if ( pgMaResInfo->dFmMode == MARESMGR_FMMODE_FREE ) 
	{
		bMaiMode = MaDevDrv_ReadIntermediateReg( MAI_MODE );
		if ( dFmMode == MARESMGR_FMMODE_4OP )
			bMaiMode &= ~MAB_FMMODE;
		else
			bMaiMode |= MAB_FMMODE;
		MaDevDrv_WriteIntermediateReg( MAI_MODE, bMaiMode );
		pgMaResInfo->dFmMode = dFmMode;
	}
	else if ( pgMaResInfo->dFmMode != dFmMode )
	{
		MARESMGR_DBGMSG(("can't change FM mode\n"));
		return MASMW_ERROR_RESOURCE_OVER;
	}

	pgMaResInfo->dFmMap |= dFmMap;

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

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_FreeFmVoice
 *
 *	Function:
 *			Free the specified FM voice resources.
 *	Argument:
 *			dFmMap	bit mapping of FM voice resources to free
 *	Return:
 *			0		success
 *			< 0		error codes
 *
 ****************************************************************************/
SINT32 MaResMgr_FreeFmVoice
(
	UINT32	dFmMap						/* FM voice map */
)
{
	UINT8	bMaiMode;

	MARESMGR_DBGMSG(("    MaResMgr_FreeFmVoice     : dFmMap=%08lX", dFmMap));

	if ( dFmMap == 0x00000000 ) return MASMW_SUCCESS;

	if ( ( dFmMap & MARESMGR_FM_MAP_MASK ) != dFmMap )
	{
		MARESMGR_DBGMSG(("illegal fm voice value\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( pgMaResInfo->dFmMap & dFmMap ) != dFmMap )
	{
		MARESMGR_DBGMSG(("can't free fm map\n"));
		return MASMW_ERROR;
	}

	pgMaResInfo->dFmMap &= ~dFmMap;
	
	if ( pgMaResInfo->dFmMap == 0 )
	{
		bMaiMode = MaDevDrv_ReadIntermediateReg( MAI_MODE );
		bMaiMode &= ~MAB_FMMODE;
		MaDevDrv_WriteIntermediateReg( MAI_MODE, bMaiMode );
		pgMaResInfo->dFmMode = MARESMGR_FMMODE_FREE;
	}

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

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

	if ( dWtMap == 0x00000000 ) return MASMW_SUCCESS;

	if ( ( dWtMap & MARESMGR_WT_MAP_MASK ) != dWtMap )
	{
		MARESMGR_DBGMSG(("illegal wt voice value\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( pgMaResInfo->dWtMap & dWtMap ) != 0 )
	{
		MARESMGR_DBGMSG(("can't alloc wt voice\n"));
		return MASMW_ERROR_RESOURCE_OVER;
	}

	pgMaResInfo->dWtMap |= dWtMap;

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

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

	if ( dWtMap == 0x00000000 ) return MASMW_SUCCESS;

	if ( ( dWtMap & MARESMGR_WT_MAP_MASK ) != dWtMap )
	{
		MARESMGR_DBGMSG(("illegal wt voice value\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( pgMaResInfo->dWtMap & dWtMap ) != dWtMap )
	{
		MARESMGR_DBGMSG(("can't free wt map\n"));
		return MASMW_ERROR;
	}

	pgMaResInfo->dWtMap &= ~dWtMap;

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

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_AllocStreamAudio
 *
 *	Function:
 *			Allocate the specified stream audio resources.
 *	Argument:
 *			dSaMap	bit mapping of Stream Audio resources to allocate.
 *	Return:
 *			0		success
 *			< 0		error code
 *
 ****************************************************************************/
SINT32 MaResMgr_AllocStreamAudio
(
	UINT32	dSaMap						/* stream audio id */
)
{
	SINT32	sdResult;
	UINT8	bMaiMode;
	static const UINT32 dWtResMap[4] = { 0x00000000, 0x02000000, 0x04000000, 0x06000000 };
	
	MARESMGR_DBGMSG(("    MaResMgr_AllocStreamAudio: dSaMap=%08lX\n", dSaMap));

	if ( dSaMap == 0x00000000 ) return MASMW_SUCCESS;

	if ( ( dSaMap & MARESMGR_SA_MAP_MASK ) != dSaMap )
	{
		MARESMGR_DBGMSG(("Illegal dSaMap value.\n"));
		return MASMW_ERROR_ARGUMENT;
	}

	if ( ( pgMaResInfo->dSaMap & dSaMap ) != 0 )
	{
		MARESMGR_DBGMSG(("can't alloc stream audio\n"));
		return MASMW_ERROR_RESOURCE_OVER;
	}

	sdResult = MaResMgr_AllocWtVoice( dWtResMap[dSaMap] );
	if ( sdResult != MASMW_SUCCESS ) return sdResult;

	sdResult = MaResMgr_AllocSoftInt( dSaMap );
	if ( sdResult != MASMW_SUCCESS )
	{
		MaResMgr_FreeWtVoice( dWtResMap[dSaMap] );
		return sdResult;
	}

	sdResult = MaResMgr_AllocStreamInt( dSaMap, MARESMGR_STREAM_INT_POINT, MARESMGR_STREAM_BUF_SIZE );
	if ( sdResult != MASMW_SUCCESS )
	{
		MaResMgr_FreeWtVoice( dWtResMap[dSaMap] );
		MaResMgr_FreeSoftInt( dSaMap );
		return sdResult;
	}

	if ( pgMaResInfo->dSaMap == 0 )
	{
		bMaiMode = MaDevDrv_ReadIntermediateReg( MAI_MODE );
		bMaiMode |= MAB_STMMODE;
		MaDevDrv_WriteIntermediateReg( MAI_MODE, bMaiMode );
	}

	pgMaResInfo->dSaMap |= dSaMap;

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

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_FreeStreamAudio
 *
 *	Function:
 *			Free the specified stream audio resources.
 *	Argument:
 *			dSaMap	bit mapping of Stream Audio resources to free.
 *	Return:
 *			0		success
 *			< 0		error codes
 *
 ****************************************************************************/
SINT32 MaResMgr_FreeStreamAudio
(
	UINT32	dSaMap						/* stream audio map */
)
{
	SINT32	sdResult;
	UINT8	bMaiMode;
	UINT32	dErrCount;
	static const UINT32 dWtResMap[4] = { 0x00000000, 0x02000000, 0x04000000, 0x06000000 };

	MARESMGR_DBGMSG(("    MaResMgr_FreeStreamAudio : dSaMap=%08lX\n", dSaMap));

	if ( dSaMap == 0x00000000 ) return MASMW_SUCCESS;

	if ( ( dSaMap & MARESMGR_SA_MAP_MASK ) != dSaMap )
	{
		MARESMGR_DBGMSG(("illegal stream audio id\n"));
		return MASMW_ERROR_ARGUMENT;
	}

	if ( ( pgMaResInfo->dSaMap & dSaMap ) != dSaMap )
	{
		MARESMGR_DBGMSG(("can't free sa\n"));
		return MASMW_ERROR;
	}

	dErrCount = 0;
	
	sdResult = MaResMgr_FreeWtVoice( dWtResMap[dSaMap] );
	if ( sdResult != MASMW_SUCCESS ) dErrCount++;

	sdResult = MaResMgr_FreeSoftInt( dSaMap );
	if ( sdResult != MASMW_SUCCESS ) dErrCount++;

	sdResult = MaResMgr_FreeStreamInt( dSaMap );
	if ( sdResult != MASMW_SUCCESS ) dErrCount++;;

	pgMaResInfo->dSaMap &= ~dSaMap;
	
	if ( pgMaResInfo->dSaMap == 0 )
	{
		bMaiMode = MaDevDrv_ReadIntermediateReg( MAI_MODE );
		bMaiMode &= ~MAB_STMMODE;
		MaDevDrv_WriteIntermediateReg( MAI_MODE, bMaiMode );
	}

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

	if ( dErrCount > 0 )
	{
		MARESMGR_DBGMSG(("can't free resource for stream audio\n"));
		return MASMW_ERROR;
	}
		
	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_AllocAl
 *
 *	Function:
 *			Allocate the specified AL voice resources.
 *	Argument:
 *			dWtMap	bit mapping of AL voice resources to allocate.
 *	Return:
 *			0		success
 *			< 0		error codes
 *
 ****************************************************************************/
SINT32 MaResMgr_AllocAl
(
	UINT32	dAlMap						/* AL voice map */
)
{
	MARESMGR_DBGMSG(("    MaResMgr_AllocAl    : dAlMap=%08lX", dAlMap));

	if ( dAlMap == 0x00000000 ) return MASMW_SUCCESS;

	if ( ( dAlMap & MARESMGR_AL_MAP_MASK ) != dAlMap )
	{
		MARESMGR_DBGMSG(("illegal al voice value\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( pgMaResInfo->dAlMap & dAlMap ) != 0 )
	{
		MARESMGR_DBGMSG(("can't alloc al voice\n"));
		return MASMW_ERROR_RESOURCE_OVER;
	}

	pgMaResInfo->dAlMap |= dAlMap;

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

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

	if ( dAlMap == 0x00000000 ) return MASMW_SUCCESS;

	if ( ( dAlMap & MARESMGR_AL_MAP_MASK ) != dAlMap )
	{
		MARESMGR_DBGMSG(("illegal al voice value\n"));
		return MASMW_ERROR_ARGUMENT;
	}
	
	if ( ( pgMaResInfo->dAlMap & dAlMap ) != dAlMap )
	{
		MARESMGR_DBGMSG(("can't free al map\n"));
		return MASMW_ERROR;
	}

	pgMaResInfo->dAlMap &= ~dAlMap;

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

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_AllocHv
 *
 *	Function:
 *			Allocate the specified HV voice resources.
 *	Argument:
 *			dHvMap	bit mapping of HV voice resources to allocate.
 *	Return:
 *			0		success
 *			< 0		error code
 *
 ****************************************************************************/
SINT32 MaResMgr_AllocHv
(
	UINT32	dHvMap						/* HV voice map */
)
{
	SINT32	sdResult;
	UINT8	bMaiMode;
	static const UINT32 dWtResMap = 0x01FF0000;
	
	MARESMGR_DBGMSG(("    MaResMgr_AllocHv: dHvMap=%08lX\n", dHvMap));

	if ( dHvMap == 0x00000000 ) return MASMW_SUCCESS;

	if ( ( dHvMap & MARESMGR_HV_MAP_MASK ) != dHvMap )
	{
		MARESMGR_DBGMSG(("Illegal HV voice map.\n"));
		return MASMW_ERROR_ARGUMENT;
	}

	if ( ( pgMaResInfo->dHvMap & dHvMap ) != 0 )
	{
		MARESMGR_DBGMSG(("can't alloc HV voice\n"));
		return MASMW_ERROR_RESOURCE_OVER;
	}

	sdResult = MaResMgr_AllocWtVoice( dWtResMap );
	if ( sdResult != MASMW_SUCCESS ) return sdResult;
	
	if ( pgMaResInfo->dHvMap == 0 )
	{
		bMaiMode = MaDevDrv_ReadIntermediateReg( MAI_MODE );
		bMaiMode |= MAB_HVMODE;
		MaDevDrv_WriteIntermediateReg( MAI_MODE, bMaiMode );
	}

	pgMaResInfo->dHvMap |= dHvMap;

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

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaResMgr_FreeHv
 *
 *	Function:
 *			Free the specified HV voice resources.
 *	Argument:
 *			dHvMap	bit mapping of HV voice resources to free.
 *	Return:
 *			0		success
 *			< 0		error codes
 *
 ****************************************************************************/
SINT32 MaResMgr_FreeHv
(
	UINT32	dHvMap						/* HV voice map */
)
{
	SINT32	sdResult;
	UINT8	bMaiMode;
	static const UINT32 dWtResMap = 0x01FF0000;

	MARESMGR_DBGMSG(("    MaResMgr_FreeHv : dHvMap=%08lX\n", dHvMap));

	if ( dHvMap == 0x00000000 ) return MASMW_SUCCESS;

	if ( ( dHvMap & MARESMGR_HV_MAP_MASK ) != dHvMap )
	{
		MARESMGR_DBGMSG(("illegal HV voice map\n"));
		return MASMW_ERROR_ARGUMENT;
	}

	if ( ( pgMaResInfo->dHvMap & dHvMap ) != dHvMap )
	{
		MARESMGR_DBGMSG(("can't free HV voice\n"));
		return MASMW_ERROR;
	}

	sdResult = MaResMgr_FreeWtVoice( dWtResMap );
	if ( sdResult != MASMW_SUCCESS ) return sdResult;
	
	pgMaResInfo->dHvMap &= ~dHvMap;
	
	if ( pgMaResInfo->dHvMap == 0 )
	{
		bMaiMode = MaDevDrv_ReadIntermediateReg( MAI_MODE );
		bMaiMode &= ~MAB_HVMODE;
		MaDevDrv_WriteIntermediateReg( MAI_MODE, bMaiMode );
	}

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

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

	if ( dLedMap == 0x00000000 ) return MASMW_SUCCESS;

	if ( ( dLedMap & MARESMGR_LD_MAP_MASK ) != dLedMap )
	{
		MARESMGR_DBGMSG(("illegal led map\n"));
		return MASMW_ERROR_ARGUMENT;
	}

	if ( ( pgMaResInfo->dLedMap & dLedMap ) != 0 )
	{
		MARESMGR_DBGMSG(("can't alloc led\n"));
		return MASMW_ERROR_RESOURCE_OVER;
	}

	pgMaResInfo->dLedMap |= dLedMap;

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

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

	if ( dLedMap == 0x00000000 ) return MASMW_SUCCESS;