madevdrv.c

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

			cinfo_ptr->streaminfo.wave_size[sa_id] -= wave_size;

			ram_adrs += wave_size;
			ram_size -= wave_size; 
			MaDevDrv_SendDirectRamVal( ram_adrs, ram_size, zero_val );
		}
		else
		{
			MaDevDrv_SendDirectRamData( ram_adrs, 0, wave_ptr, ram_size );

			cinfo_ptr->streaminfo.wave_ptr[sa_id]  += ram_size;
			cinfo_ptr->streaminfo.wave_size[sa_id] -= ram_size;
		}

		cinfo_ptr->streaminfo.write_block[sa_id] = read_block;
		cinfo_ptr->streaminfo.read_block[sa_id]  = pg_point;
	}
	else
	{
		/* 1 */
		ram_size = (UINT32)(MA_MAX_PG - write_block);

		wave_ptr  = cinfo_ptr->streaminfo.wave_ptr[sa_id];
		wave_size = cinfo_ptr->streaminfo.wave_size[sa_id];

		if ( ram_size > wave_size )
		{
			MaDevDrv_SendDirectRamData( ram_adrs, 0, wave_ptr, wave_size );

			ram_adrs += wave_size;
			ram_size -= wave_size; 
			MaDevDrv_SendDirectRamVal( ram_adrs, ram_size, zero_val );

			cinfo_ptr->streaminfo.wave_ptr[sa_id]  += wave_size;
			cinfo_ptr->streaminfo.wave_size[sa_id] -= wave_size;
		}
		else
		{
			MaDevDrv_SendDirectRamData( ram_adrs, 0, wave_ptr, ram_size );

			if ( ( format > 1 ) && ( ram_size != 0 ) ) ram_size--;

			cinfo_ptr->streaminfo.wave_ptr[sa_id]  += ram_size;
			cinfo_ptr->streaminfo.wave_size[sa_id] -= ram_size;
		}

		cinfo_ptr->streaminfo.write_block[sa_id] = read_block;
		cinfo_ptr->streaminfo.read_block[sa_id]  = pg_point;

		/* 2 */
		ram_adrs = (UINT32)(MA_MIN_PG + MA_RAM_START_ADDRESS + (MA_RAM_BLOCK_SIZE * (7-sa_id)) + 0x20);
		ram_size = (UINT32)(read_block - MA_MIN_PG);

		if ( ram_size != 0 )
		{
			wave_ptr  = cinfo_ptr->streaminfo.wave_ptr[sa_id];
			wave_size = cinfo_ptr->streaminfo.wave_size[sa_id];

			if ( ram_size > wave_size )
			{
				MaDevDrv_SendDirectRamData( ram_adrs, 0, wave_ptr, wave_size );

				ram_adrs += wave_size;
				ram_size -= wave_size;
				MaDevDrv_SendDirectRamVal( ram_adrs, ram_size, zero_val );

				cinfo_ptr->streaminfo.wave_ptr[sa_id]  += wave_size;
				cinfo_ptr->streaminfo.wave_size[sa_id] -= wave_size;
			}
			else
			{
				MaDevDrv_SendDirectRamData( ram_adrs, 0, wave_ptr, ram_size );

				cinfo_ptr->streaminfo.wave_ptr[sa_id]  += ram_size;
				cinfo_ptr->streaminfo.wave_size[sa_id] -= ram_size;
			}

			cinfo_ptr->streaminfo.write_block[sa_id] = read_block;
			cinfo_ptr->streaminfo.read_block[sa_id]  = pg_point;
		}
	}


	switch ( cinfo_ptr->streaminfo.state[sa_id] )
	{
	case 2:

		if ( cinfo_ptr->streaminfo.wave_size[sa_id] == 0 )
		{
			cinfo_ptr->streaminfo.prv_point[sa_id] = pg_point;
			cinfo_ptr->streaminfo.state[sa_id] = 3;
		}
		break;
			
	case 3:

		end_point = cinfo_ptr->streaminfo.end_point[sa_id];
		prv_point = cinfo_ptr->streaminfo.prv_point[sa_id];

		if ( ( ( end_point <  pg_point  ) && ( pg_point  <  prv_point ) )
		  || ( ( pg_point  <  prv_point ) && ( prv_point <= end_point ) )
		  || ( ( prv_point <= end_point ) && ( end_point <  pg_point  ) ) )
		{
			
			cinfo_ptr->streaminfo.state[sa_id] = 0;

			cinfo_ptr->timer0 &= (UINT8)~(1 << sa_id);

			if ( cinfo_ptr->timer0 == 0 )
			{
				packet[0] = (UINT8)(  MA_TIMER_0_CTRL     & 0x7F );
				packet[1] = (UINT8)( (MA_TIMER_0_CTRL>>7) | 0x80 );
				packet[2] = (UINT8)(                        0x80 );
				MaDevDrv_SendDirectPacket( packet, 3 );
			}

			/* KeyOff */
			reg_index = (UINT32)( MA_WT_VOICE_ADDRESS + (7-(UINT32)sa_id) * 6 + 5 );
			ch = (UINT8)( MaDevDrv_ReceiveData( reg_index, 0 ) & 0x0F );

			packet[0] = (UINT8)(  reg_index       & 0x7F );		/* address part */
			packet[1] = (UINT8)( (reg_index >> 7) | 0x80 );
			packet[2] = (UINT8)(  0x00 | ch       | 0x80 );		/* data part */
			MaDevDrv_SendDirectPacket( packet, 3 );

			if ( cinfo_ptr->audio_mode == 1 )
			{
				result = MaSound_ReceiveMessage( 2, 0, 128 );
				result = MaSound_ReceiveMessage( 2, 0, 127 );
			}
		}
		else
		{
			cinfo_ptr->streaminfo.prv_point[sa_id] = pg_point;
		}

		break;
	
	default:
		break;
	}

	return result;
}
/****************************************************************************
 *	MaDevDrv_StreamHandler
 *
 *	Description:
 *			Control the stream audio.
 *	Arguments:
 *			sa_id		stream audio slot number
 *			ctrl		0: setup
 *						1: update
 *			ram			SINT RAM register value
 *	Return:
 *			None
 *
 ****************************************************************************/
SINT32 MaDevDrv_StreamHandler
(
	UINT8	sa_id,						/* stream audio number */
	UINT8	ctrl,						/* control */
	UINT8	ram_val
)
{
	UINT8	packet[6];
	UINT8	format;
	UINT8 *	wave_ptr;
	UINT32	wave_size;
	UINT8	wave_id[2];
	UINT8	sa_slot[2];
	SINT32	result;
	UINT32	reg_index;
	UINT8	ch;
	UINT8	num_saon;
	UINT8	i;
	UINT8	num;
	UINT32	seek_pos;

	MADEVDRV_DBGMSG(("MaDevDrv_StreamHandler: sa_id=%d ctrl=%d ram_val=%d\n", sa_id, ctrl, ram_val));

	if ( sa_id >= MA_MAX_STREAM_AUDIO ) return MASMW_ERROR;

	_ma_intstate |= (UINT8)(1 << 1);

	if ( ctrl == 0 )						/* setup */
	{
		if ( ( ram_val & 0x40 ) != 0 )
		{

			wave_id[0] = (UINT8)( ram_val & 0x1F );
			sa_slot[0] = sa_id;
			num_saon = 1;

			cinfo_ptr->streaminfo.position[sa_id] = 0;

			if ( ( ram_val & 0x20 ) != 0 )
			{
				sa_slot[1] = (UINT8)( ( sa_id == 0 ) ? 1 : 0 );
				wave_id[1] = (UINT8)( MaDevDrv_ReceiveData( MA_SOFTINT_RAM + sa_slot[1], 0 ) & 0x1F );
				num_saon++;
			}

			for ( i = 0; i < num_saon; i++ )
			{
				if ( cinfo_ptr->streaminfo.state[sa_slot[i]] != 0 )
				{
					reg_index = (UINT32)( MA_WT_VOICE_ADDRESS + (7-(UINT32)sa_slot[i]) * 6 + 5 );
					ch = (UINT8)( MaDevDrv_ReceiveData( reg_index, 0 ) & 0x0F );

					packet[0] = (UINT8)(  reg_index       & 0x7F );		/* address part */
					packet[1] = (UINT8)( (reg_index >> 7) | 0x80 );
					packet[2] = (UINT8)(  0x00 | ch       | 0x80 );		/* data part */
					MaDevDrv_SendDirectPacket( packet, 3 );
				}

				result = MaResMgr_GetStreamAudioInfo( wave_id[i], &format, &wave_ptr, &wave_size, &seek_pos );
				if ( result != MASMW_SUCCESS )
				{
					_ma_intstate &= (UINT8)~(1 << 1);
					return result;
				}

				cinfo_ptr->streaminfo.write_block[sa_slot[i]] = (UINT16)MA_MIN_PG;
				cinfo_ptr->streaminfo.read_block[sa_slot[i]]  = (UINT16)MA_MIN_PG;
				cinfo_ptr->streaminfo.state[sa_slot[i]]		  = 1;
				cinfo_ptr->streaminfo.format[sa_slot[i]]	  = format;
				cinfo_ptr->streaminfo.wave_ptr[sa_slot[i]] 	  = wave_ptr  + seek_pos;
				cinfo_ptr->streaminfo.wave_size[sa_slot[i]]   = wave_size - seek_pos;

				MaDevDrv_StreamSetup( sa_slot[i] );

				if ( cinfo_ptr->seq_flag == 1 )
				{
					if ( cinfo_ptr->timer0 == 0 )
					{
						packet[0] = (UINT8)(  MA_TIMER_0_CTRL     & 0x7F );
						packet[1] = (UINT8)( (MA_TIMER_0_CTRL>>7) | 0x80 );
						packet[2] = (UINT8)( 0x81 );
						MaDevDrv_SendDirectPacket( packet, 3 );
					}

					cinfo_ptr->timer0 |= (1 << sa_slot[i]);
				}
			}

			num = 0;
			for ( i = 0; i < num_saon; i++ )
			{
				reg_index = (UINT32)( MA_WT_VOICE_ADDRESS + (7-(UINT32)sa_slot[i]) * 6 + 5 );
				ch = (UINT8)( MaDevDrv_ReceiveData( reg_index, 0 ) & 0x0F );

				packet[num++] = (UINT8)(  reg_index       & 0x7F );		/* address part */
				packet[num++] = (UINT8)( (reg_index >> 7) | 0x80 );
				packet[num++] = (UINT8)(  0x40 | ch       | 0x80 );		/* data part */
			}

			if ( num != 0 )
				MaDevDrv_SendDirectPacket( packet, num );
		}
		else
		{

			cinfo_ptr->streaminfo.state[sa_id] = 0;

			cinfo_ptr->timer0 &= (UINT8)~(1 << sa_id);


			if ( cinfo_ptr->timer0 == 0 )
			{
				packet[0] = (UINT8)(  MA_TIMER_0_CTRL     & 0x7F );
				packet[1] = (UINT8)( (MA_TIMER_0_CTRL>>7) | 0x80 );
				packet[2] = (UINT8)(                        0x80 );
				MaDevDrv_SendDirectPacket( packet, 3 );
			}

			reg_index = (UINT32)( MA_WT_VOICE_ADDRESS + (7-(UINT32)sa_id) * 6 + 5 );
			ch = (UINT8)( MaDevDrv_ReceiveData( reg_index, 0 ) & 0x0F );

			packet[0] = (UINT8)(  reg_index       & 0x7F );		/* address part */
			packet[1] = (UINT8)( (reg_index >> 7) | 0x80 );
			packet[2] = (UINT8)(  0x00 | ch       | 0x80 );		/* data part */
			MaDevDrv_SendDirectPacket( packet, 3 );
		}
	}
	else									/* update */
	{
		switch ( cinfo_ptr->streaminfo.state[sa_id] )
		{
		case 0:
			break;
			
		case 1:
			break;
			
		case 2:
		case 3:

			MaDevDrv_StreamUpdate( sa_id );
			break;
		}
	}

	_ma_intstate &= (UINT8)~(1 << 1);

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaDevDrv_SoftInt0
 *
 *	Description:
 *			Software interrupt #0 interrupt handler.
 *	Argument:
 *			ctrl	unused
 *	Return:
 *			None
 *
 ****************************************************************************/
void MaDevDrv_SoftInt0
(
	UINT8	ctrl
)
{
	UINT8	ram_val1;					/* ram value */

	(void)ctrl;							/* for unused warning message */

	MADEVDRV_DBGMSG(("MaDevDrv_SoftInt0: ctrl=%d\n", ctrl));

	ram_val1 = (UINT8)MaDevDrv_ReceiveData( MA_SOFTINT_RAM + 0, 0 );

	MaDevDrv_StreamHandler( 0, 0, ram_val1 );	/* SA #0, setup */

}
/****************************************************************************
 *	MaDevDrv_SoftInt1
 *
 *	Description:
 *			Software interrupt #1 interrupt handler.
 *	Argument:
 *			ctrl	unused
 *	Return:
 *			None
 *
 ****************************************************************************/
void MaDevDrv_SoftInt1
(
	UINT8	ctrl
)
{
	UINT8	ram_val1;					/* ram value */

	(void)ctrl;							/* for unused warning message */

	MADEVDRV_DBGMSG(("MaDevDrv_SoftInt1: ctrl=%d\n", ctrl));

	ram_val1 = (UINT8)MaDevDrv_ReceiveData( MA_SOFTINT_RAM + 1, 0 );

	MaDevDrv_StreamHandler( 1, 0, ram_val1 );	/* SA #1, setup */

}
/****************************************************************************
 *	MaDevDrv_SoftInt2
 *
 *	Description:
 *			Software interrupt #2 interrupt handler.
 *	Argument:
 *			ctrl	unused
 *	Return:
 *			None
 *
 ****************************************************************************/
void MaDevDrv_SoftInt2
(
	UINT8	ctrl
)
{
	UINT8	event;					/* event value */

	(void)ctrl;						/* for unused warning message */

	MADEVDRV_DBGMSG(("MaDevDrv_SoftInt2: ctrl=%d\n", ctrl));

	event = (UINT8)MaDevDrv_ReceiveData( MA_SOFTINT_RAM + 2, 0 );

	MaSound_ReceiveMessage( 0, 0, event );
}
/****************************************************************************
 *	MaDevDrv_SoftInt3
 *
 *	Description:
 *			Software interrupt #3 interrupt handler.
 *	Argument:
 *			ctrl	unused
 *	Return:
 *			None
 *
 ****************************************************************************/
void MaDevDrv_SoftInt3
(
	UINT8	ctrl
)
{
	UINT8	event;					/* event value */

	(void)ctrl;						/* for unused warning message */

	MADEVDRV_DBGMSG(("MaDevDrv_SoftInt3: ctrl=%d\n", ctrl));

	event = (UINT8)MaDevDrv_ReceiveData( MA_SOFTINT_RAM + 3, 0 );

	MaSound_ReceiveMessage( 0, 0, event );
}
/****************************************************************************
 *	MaDevDrv_Timer0
 *
 *	Description:
 *			Timer #0 interrupt handler.
 *	Argument:
 *			ctrl	unused
 *	Return:
 *			None
 *
 ****************************************************************************/
void MaDevDrv_Timer0
(
	UINT8	ctrl
)
{
	SINT32 	result;				/* result of function */
	UINT8	sa_id;				/* stream audio number */

	(void)ctrl;					/* for unused warning message */

	MADEVDRV_DBGMSG(("MaDevDrv_Timer0: ctrl=%d\n", ctrl));

	for ( sa_id = 0; sa_id < MA_MAX_STREAM_AUDIO; sa_id++ )
	{
		result = MaDevDrv_StreamHandler( sa_id, 1, 0 );	/* update */
		if ( result != MASMW_SUCCESS ) return;
	}

	if ( ( cinfo_ptr->timer0 & (UINT8)0x0C ) != 0 )
	{
		result = MaSndDrv_UpdateSequence( 1, NULL, 0 );
	}
}
/****************************************************************************
 *	MaDevDrv_Timer1
 *
 *	Description:
 *			Timer #1 interrupt handler.
 *	Argument:
 *			ctrl
 *	Return:
 *			None
 *
 ****************************************************************************/
void MaDevDrv_Timer1
(
	UINT8	ctrl
)
{
	MADEVDRV_DBGMSG(("MaDevDrv_Timer1: ctrl=%d\n", ctrl));

	(void)ctrl;

	MaSndDrv_UpdatePos( 0, 1 );
}
/****************************************************************************
 *	MaDevDrv_Fifo
 *
 *	Description:
 *			Update sequence data to sequence FIFO.
 *	Argument:
 *			ctrl
 *	Return:
 *			None
 *