madevdrv.c

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

 ****************************************************************************/
void MaDevDrv_Fifo
(
	UINT8	ctrl
)
{
	UINT8 *	buf_ptr;
	UINT32	buf_size;
	SINT32	wrote_size;
	UINT32	send_buf_size;
	UINT8	i;
	UINT8	packet[3] = { (   ( MA_SEQUENCE + 2 )        & 0x7F ),
						  ( ( ( MA_SEQUENCE + 2 ) >> 7 ) | 0x80 ),
						  0x80 };

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

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

	if ( cinfo_ptr->end_of_sequence[0] == 2 )
	{
		cinfo_ptr->end_of_sequence[0] = 0;
		MaDevDrv_StopSequencer( 0, 1 );

		packet[2] = (0x80 | MA_INT_POINT);
		MaDevDrv_SendDirectPacket( packet, 3 );

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

		return;
	}

	wrote_size = 0;
	send_buf_size = 0;
	for ( i = 0; i <= ctrl; i++ )
	{
		buf_ptr  = cinfo_ptr->sbuf_buffer[cinfo_ptr->sbuf_info.read_num];
		buf_size = cinfo_ptr->sbuf_info.buf_size[cinfo_ptr->sbuf_info.read_num];
		if ( buf_size != 0 )
		{
			if ( cinfo_ptr->ctrl_seq != 0 )
			{
				if ( machdep_CheckDelayedFifoEmpty()!=0 )
				{
					MaDevDrv_StopSequencer( 0, 0 );
					cinfo_ptr->stop_flag = 1;
					cinfo_ptr->stop_reg  = 1;

					machdep_WriteStatusFlagReg( MA_BASIC_SETTING_REG );
					machdep_WriteDataReg( 0x20 );
					machdep_Wait( 300 );
					machdep_WriteDataReg( 0x00 );
					machdep_WriteStatusFlagReg( cinfo_ptr->mask_interrupt );
				}
			}
			MaDevDrv_SendDelayedPacket( buf_ptr, (UINT16)buf_size );

			cinfo_ptr->sbuf_info.buf_size[cinfo_ptr->sbuf_info.read_num] = 0;

			cinfo_ptr->sbuf_info.read_num++;
			if ( cinfo_ptr->sbuf_info.read_num == MA_SBUF_NUM )
			{
				cinfo_ptr->sbuf_info.read_num = 0;
			}
		}
		send_buf_size += buf_size;
		
		if ( cinfo_ptr->end_of_sequence[0] == 1 ) continue;
		
		buf_ptr	 = cinfo_ptr->sbuf_buffer[cinfo_ptr->sbuf_info.write_num];
		buf_size = MA_FIFO_SIZE;
		if ( buf_size != 0 )
		{
			wrote_size = MaSndDrv_UpdateSequence( 0, buf_ptr, buf_size  );
			if ( wrote_size >= 0 )
				cinfo_ptr->sbuf_info.buf_size[cinfo_ptr->sbuf_info.write_num] = (UINT16)wrote_size;

			cinfo_ptr->sbuf_info.write_num++;
			if ( cinfo_ptr->sbuf_info.write_num == MA_SBUF_NUM )
			{
				cinfo_ptr->sbuf_info.write_num = 0;
			}
		}
	}

	if ( ( cinfo_ptr->stop_flag == 1 ) && ( cinfo_ptr->ctrl_seq != 0 ) )
	{
		machdep_WriteStatusFlagReg( MA_BASIC_SETTING_REG );
		machdep_WriteDataReg( 0x08 );
		machdep_Wait( 300 );
		machdep_WriteDataReg( 0x00 );
		machdep_WriteStatusFlagReg( cinfo_ptr->mask_interrupt );

		cinfo_ptr->stop_flag = 0;
		MaDevDrv_StartSequencer( 0, 0 );
	}

	if ( ( ctrl == 0 ) && ( send_buf_size == 0 ) && ( wrote_size == 0 ) && ( cinfo_ptr->end_of_sequence[0] == 1 ) )
	{
		MaDevDrv_SendDirectPacket( packet, 3 );
		cinfo_ptr->end_of_sequence[0]++;
	}

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

#ifdef COLORLED_SUPPORT
    /* output to CPU GPIO */
	switch( abLedPattern[dwLedCount] ){
		case 0: //RGB -- 000 
			Red_Off();
			Green2_Off();      
			Blue_Off();
			break;
		case 1: //RGB-- 001
			Red_Off();          
			Green2_Off();      
			Blue_On();
			break;
		case 2: //RGB -- 010
			Red_Off();          
			Green2_On();      
			Blue_Off();
			break;
		case 3: //RGB-- 011
			Red_Off();          
			Green2_On();      
			Blue_On();
			break;
		case 4: //RGB -100
			Red_On();          
			Green2_Off();      
			Blue_Off();
			break;
		case 5: //RGB -101
			Red_On();          
			Green2_Off();      
			Blue_On();
			break;
		case 6://RGB -110
			Red_On();          
			Green2_On();      
			Blue_Off();
		case 7://RGB -111
			Red_On();          
			Green2_On();      
			Blue_On();
			break;
		}

    dwLedCount++;
    if ( dwLedCount >= MADEVDRV_LED_PATTERN_NUM ) {
    	dwLedCount = 0;
    }
#endif    
}
/****************************************************************************
 *	MaDevDrv_ClearFifo
 *
 *	Description:
 *			Clear FIFO.
 *	Argument:
 *			None
 *	Return:
 *			0		success
 *			< 0		error code
 *
 ****************************************************************************/
SINT32 MaDevDrv_ClearFifo
(void)
{
	SINT32	i;
	static UINT8 packet[3] = { (   ( MA_SEQUENCE + 2 )        & 0x7F ),
							   ( ( ( MA_SEQUENCE + 2 ) >> 7 ) | 0x80 ),
							   (     MA_INT_POINT             | 0x80 ) };

	MADEVDRV_DBGMSG(("MaDevDrv_ClearFifo\n"));
	
	machdep_WriteStatusFlagReg( MA_BASIC_SETTING_REG );
	machdep_WriteDataReg( 0x28 );
	machdep_Wait( 300 );						/* wait 300ns */
	machdep_WriteDataReg( 0x00 );

	MaDevDrv_SendDirectPacket( packet, 3 );

	cinfo_ptr->sbuf_info.write_num = 0;
	cinfo_ptr->sbuf_info.read_num  = 0;
	for ( i = 0; i < MA_SBUF_NUM; i++ )
	{
		cinfo_ptr->sbuf_info.buf_size[i] = 0;
	}

	machdep_WriteStatusFlagReg( cinfo_ptr->mask_interrupt );

	cinfo_ptr->end_of_sequence[0] = 0;

	cinfo_ptr->stop_flag = 0;
	cinfo_ptr->stop_reg = 0;

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaDevDrv_StartSequencer
 *
 *	Description:
 *			Start sequencer.
 *	Argument:
 *			seq_id	sequence id
 *			ctrl
 *	Return:
 *			0		success
 *			< 0		error code
 *
 ****************************************************************************/
SINT32 MaDevDrv_StartSequencer
(
	SINT32	seq_id,						/* sequence id */
	UINT8	ctrl						/* control flag */
)
{
	SINT32	result;						/* result of function */
	static UINT8	packet1[3] = { 0x61, 0x82, 0x81 };	/* start sequencer */
	static UINT8	packet2[3] = { 0x55, 0x82, 0x81 };	/* timer 0 start */
	UINT8	save_mask;

	MADEVDRV_DBGMSG(("MaDevDrv_StartSequencer: seq_id=%ld\n", seq_id));

	result = MASMW_SUCCESS;

	/* mask interrupt */
	machdep_WriteStatusFlagReg( (UINT8)MA_INTERRUPT_FLAG_REG );
	save_mask = cinfo_ptr->mask_interrupt;
	cinfo_ptr->mask_interrupt = 0x00;

	switch ( seq_id )
	{
	case 0:						/* delayed sequence */

		if ( ctrl == 1 ) cinfo_ptr->ctrl_seq = 1;

		MaDevDrv_ControlInterrupt( 0, 0x7F );

		result = MaDevDrv_SendDirectPacket( packet1, 3 );

		break;
	
	case 1:
	
		if ( cinfo_ptr->timer0 == 0 )
		{
			MaDevDrv_ControlInterrupt( 0, 0x1F );
		
			result = MaDevDrv_SendDirectPacket( packet2, 3 );
		}
		cinfo_ptr->timer0 |= (UINT8)(1 << 2);

		break;

	case 2:

		if ( cinfo_ptr->timer0 == 0 )
		{
			MaDevDrv_ControlInterrupt( 0, 0x1F );

			result = MaDevDrv_SendDirectPacket( packet2, 3 );
		}
		cinfo_ptr->timer0 |= (UINT8)(1 << 3);
		break;

	default:

		result = MASMW_ERROR;
		break;
	}

	cinfo_ptr->seq_flag = 1;

	/* unmask interrupt */
	cinfo_ptr->mask_interrupt = save_mask;
	if ( save_mask == 0x80 )
	{
		machdep_WriteStatusFlagReg( cinfo_ptr->mask_interrupt );
	}

	return result;
}
/****************************************************************************
 *	MaDevDrv_StopSequencer
 *
 *	Description:
 *			Stop sequencer.
 *	Argument:
 *			seq_id
 *			ctrl
 *	Return:
 *			0		success
 *			< 0		error code
 *
 ****************************************************************************/
SINT32 MaDevDrv_StopSequencer
(
	SINT32	seq_id,						/* sequence id */
	UINT8	ctrl						/* control flag */
)
{
	SINT32	result = MASMW_SUCCESS;
	static UINT8	packet1[3] = { 0x61, 0x82, 0x80 };	/* sequencer stop */
	static UINT8	packet2[3] = { 0x55, 0x82, 0x80 };	/* timer 0 stop */

	MADEVDRV_DBGMSG(("MaDevDrv_StopSequencer: seq_id=%ld\n", seq_id));

	switch ( seq_id )
	{
	case 0:						/* delayed sequence */
	
		if ( ctrl == 1 ) cinfo_ptr->ctrl_seq = 0;

		MaDevDrv_ControlInterrupt( 1, 0x60 );

		result = MaDevDrv_SendDirectPacket( packet1, 3 );

#ifdef COLORLED_SUPPORT
		/* output to CPU GPIO */
		Red_Off();
		Blue_Off();
		Green2_Off();
#endif		
		break;
	
	case 1:						/* direct sequence */
	
		cinfo_ptr->timer0 &= (UINT8)~(1 << 2);

		if ( cinfo_ptr->timer0 == 0 )
		{
			MaDevDrv_ControlInterrupt( 1, 0x00 );
		
			result = MaDevDrv_SendDirectPacket( packet2, 3 );
		}
		
		break;

	case 2:

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

		if ( cinfo_ptr->timer0 == 0 )
		{
			MaDevDrv_ControlInterrupt( 1, 0x00 );

			result = MaDevDrv_SendDirectPacket( packet2, 3 );
		}
		break;

	default:
	
		result = MASMW_ERROR;
		break;
	}

	cinfo_ptr->seq_flag = 0;

	return result;
}
/****************************************************************************
 *	MaDevDrv_EndOfSequence
 *
 *	Description:
 *			Receive the end of sequence.
 *	Argument:
 *			None
 *	Return:
 *			0		success
 *			< 0		error code
 *
 ****************************************************************************/
SINT32 MaDevDrv_EndOfSequence
(
	void
)
{
	MADEVDRV_DBGMSG(("MaDevDrv_EndOfSequence:\n"));

	cinfo_ptr->end_of_sequence[0] = 1;

	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaDevDrv_InitRegisters
 *
 *	Description:
 *			Initialize the uninitialized registers by software reset
 *	Argument:
 *			None
 *	Return:
 *			None
 *
 ****************************************************************************/
void MaDevDrv_InitRegisters
(
	void
)
{
	UINT8	count;
	
	static UINT8 index[15] = { 0x00, 0x04, 0x07, 0x08, 0x09, 0x0A, 0x0F, 0x04,
							   0x0B, 0x0C, 0x04, 0x05, 0x06, 0x0A, 0x0D, };

	static UINT8 data[15]  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
							   0x03, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 };

	MADEVDRV_DBGMSG(("MaDevDrv_InitRegisters:\n"));

	for ( count = 0; count < 15; count++ )
	{
		/* set index of interrupt flag register to REG_ID */
		machdep_WriteStatusFlagReg( index[count] );

		/* write data to the target register */
		machdep_WriteDataReg( data[count] );
	}
}
/****************************************************************************
 *	MaDevDrv_VerifyRegisters
 *
 *	Description:
 *			Verify the initialized registers by software reset
 *	Argument:
 *			None
 *	Return:
 *			0		success
 *			-1		error
 *
 ****************************************************************************/
SINT32 MaDevDrv_VerifyRegisters
(
	void
)
{
	UINT32	reg_adrs;					/* register address */
	UINT32	count;						/* loop count */
	UINT8	data;						/* read data */

	MADEVDRV_DBGMSG(("MaDevDrv_VerifyRegisters:\n"));

	/* Verify the channel volume value to 0x60 */
	reg_adrs = (UINT32)MA_CHANNEL_VOLUME;
	for ( count = 0; count < 16; count++ )
	{
		data = (UINT8)MaDevDrv_ReceiveData( (UINT32)(reg_adrs + count), 2 );
		if ( data != 0x60 )
		{
			MADEVDRV_DBGMSG(("MelDev:chvol=%02x", data));
			return MASMW_ERROR;
		}
	}

	/* Verify the panpot value to 0x3C */
	reg_adrs = (UINT32)MA_CHANNEL_PANPOT;
	for ( count = 0; count < 16; count++ )
	{
		data = (UINT8)MaDevDrv_ReceiveData( (UINT32)(reg_adrs + count), 2 );
		if ( data != 0x3C )
		{
			MADEVDRV_DBGMSG(("MelDev:pan=%02x", data));
			return MASMW_ERROR;
		}
	}

	/* Verify the WT position value to 0x40 */
	reg_adrs = (UINT32)MA_WT_PG;
	for ( count = 0; count < 8; count++ )
	{
		data = (UINT8)MaDevDrv_ReceiveData( (UINT32)(reg_adrs + count), 2 );
		if ( data != 0x40 )
		{
			MADEVDRV_DBGMSG(("MelDev:WT=%02x", data));
			return MASMW_ERROR;
		}
	}