spi_test.c

s3c6400 ADS下官方测试程序

//=========== SPI0 Slave Tx Setting ===========
	ch0 = SPI_open( TEST_CHANNEL0, SPI_SLAVE, SPI_TEST_CPOL, SPI_TEST_FORMAT, CLK_SOURCE, SPI_SPEED, SPI_TEST_CHANNEL_WIDTH, SPI_TEST_BUS_WIDTH, SPI_TEST_DMA_TYPE );
	SPI_transaction( ch0, SPI_TEST_TRANSFER_MODE, uTxBufAddr, NULL, DataCnt, callback);

// =========== SPI1 Master Rx Setting =========== 
	ch1 = SPI_open( TEST_CHANNEL1, SPI_MASTER, SPI_TEST_CPOL, SPI_TEST_FORMAT, CLK_SOURCE, SPI_SPEED, SPI_TEST_CHANNEL_WIDTH, SPI_TEST_BUS_WIDTH, SPI_TEST_DMA_TYPE );
	SPI_transaction( ch1, SPI_DMA_MODE, NULL, uRxBufAddr, DataCnt, NULL);

	while(ch0->m_uTxRemainDataSize!=0);
	
	SPI_close( ch0 );
	SPI_close( ch1 );
	if ( SPI_CompareData( uTxBufAddr, uRxBufAddr, DataCnt ) > 0 ) {
		return FALSE;
	}
	return TRUE;
}

// Test Case 6
bool SPI_SwapMasterTxOnly(void) {
	SPI_channel *ch1, *ch0;
	int DataCnt;
	u8* uMTxBufAddr = (u8*)SPI_getBuffer(0, TRUE, TRUE);
	u8* uMRxBufAddr = (u8*)SPI_getBuffer(1, FALSE, TRUE);
	u8* uSTxBufAddr = (u8*)SPI_getBuffer(2, TRUE, TRUE);
	u8* uSRxBufAddr = (u8*)SPI_getBuffer(3, FALSE, TRUE);

	DataCnt = SPI_DATA_COUNT;

// =========== SPI1 Slave Rx/Tx Setting =========== 
	ch1 = SPI_open( TEST_CHANNEL1, SPI_SLAVE, SPI_TEST_CPOL, SPI_TEST_FORMAT, CLK_SOURCE, SPI_SPEED, SPI_TEST_CHANNEL_WIDTH, SPI_TEST_BUS_WIDTH, SPI_TEST_DMA_TYPE );
//	SPI_setSwapMode( ch1, SPI_BYTE_SWAP, SPI_BYTE_SWAP);
	SPI_transaction( ch1, SPI_DMA_MODE, uSTxBufAddr, uSRxBufAddr, DataCnt, callback);

// =========== SPI0 Master Rx/Tx Setting =========== 
	ch0 = SPI_open( TEST_CHANNEL0, SPI_MASTER, SPI_TEST_CPOL, SPI_TEST_FORMAT, CLK_SOURCE, SPI_SPEED, SPI_TEST_CHANNEL_WIDTH, SPI_TEST_BUS_WIDTH, SPI_TEST_DMA_TYPE );
	ch0->m_bIsAutoChipSelection = TRUE;
//	SPI_setSwapMode( ch0, SPI_BYTE_SWAP, SPI_BYTE_SWAP);
	SPI_transaction( ch0, SPI_TEST_TRANSFER_MODE, uMTxBufAddr, uMRxBufAddr, DataCnt, NULL);
	while ( ch1->m_uTxRemainDataSize != 0 );
	while ( ch1->m_uRxRemainDataSize != 0 );
	SPI_close( ch0 );
	SPI_close( ch1 );

	printf( "master to slave\n");
	if ( SPI_CompareData( uMTxBufAddr, uSRxBufAddr, DataCnt ) > 16 ) {
		return FALSE;
	}
	printf( "slave to master\n");
	if ( SPI_CompareData( uSTxBufAddr, uMRxBufAddr, DataCnt ) > 16 ) {
		return FALSE;
	}
	return TRUE;
}

// youngbo.song Test Only - between Peripherals DMA Setting test.
bool SPI_DMA_periToPeriTest(void) {
	SPI_channel *ch1, *ch0;
	int DataCnt;
	u32 time = 0;
	u8* uMTxBufAddr = (u8*)SPI_getBuffer(0, TRUE, TRUE);
	u8* uMRxBufAddr = (u8*)SPI_getBuffer(1, FALSE, TRUE);

	DataCnt = SPI_DATA_COUNT;

// =========== SPI1 Slave Rx/Tx Setting =========== 
	ch1 = SPI_open( TEST_CHANNEL1, SPI_SLAVE, SPI_TEST_CPOL, SPI_TEST_FORMAT, CLK_SOURCE, SPI_SPEED, SPI_TEST_CHANNEL_WIDTH, SPI_TEST_BUS_WIDTH, SPI_TEST_DMA_TYPE );
	SPI_PtoPTransaction( ch1, SPI_DMA_MODE, DataCnt, callback);

// =========== SPI0 Master Rx/Tx Setting =========== 
	ch0 = SPI_open( TEST_CHANNEL0, SPI_MASTER, SPI_TEST_CPOL, SPI_TEST_FORMAT, CLK_SOURCE, SPI_SPEED, SPI_TEST_CHANNEL_WIDTH, SPI_TEST_BUS_WIDTH, SPI_TEST_DMA_TYPE );
	StartTimer(0);
	SPI_transaction( ch0, SPI_TEST_TRANSFER_MODE, uMTxBufAddr, uMRxBufAddr, DataCnt, NULL);
	time = StopTimer(0);
	printf( "BPS = %f, time:%d\n", ((float)DataCnt)/((float)time), time );
	while ( ch1->m_uTxRemainDataSize != 0 );
	while ( ch1->m_uRxRemainDataSize != 0 );
	SPI_close( ch0 );
	SPI_close( ch1 );

//	printf( "master to master\n");
	if ( SPI_CompareData( uMTxBufAddr, uMRxBufAddr, DataCnt-64 ) > 32 ) {
		printf ( "ERROR 1\n");
		return FALSE;
	}
	return TRUE;
}

//////////
// File Name : SPI_BtoBMasterFullDuplex
// File Description : Board to Board Test using Master fullduplex mode.
// Input : NONE
// Output : success or fail.
// Version : 
bool SPI_BtoBMasterFullDuplex(void) {
	SPI_channel *ch;
	int DataCnt;
	u8* uMTxBufAddr = (u8*)SPI_getBuffer(0, TRUE, TRUE);
	u8* uMRxBufAddr = (u8*)SPI_getBuffer(1, FALSE, TRUE);

	DataCnt = SPI_DATA_COUNT;
	printf( "SPI_BtoBMasterFullDuplex\n");
// =========== SPI0 Slave Rx/Tx Setting =========== 
	ch = SPI_open( TEST_CHANNEL0, SPI_MASTER, SPI_TEST_CPOL, SPI_TEST_FORMAT, CLK_SOURCE, SPI_SPEED, SPI_TEST_CHANNEL_WIDTH, SPI_TEST_BUS_WIDTH, SPI_TEST_DMA_TYPE );
	SPI_transaction( ch, SPI_DMA_MODE, NULL, uMRxBufAddr, DataCnt, NULL);
	SPI_close( ch );

	if ( SPI_CompareData( uMTxBufAddr, uMRxBufAddr, DataCnt ) > 0 ) {
		return FALSE;
	}
	return TRUE;
}

//////////
// File Name : SPI_BtoBSlaveFullDuplex
// File Description : Board to Board Test using Slave fullduplex mode.
// Input : NONE
// Output : success or fail.
// Version : 
bool SPI_BtoBSlaveFullDuplex(void) {
	SPI_channel *ch;
	int DataCnt;
	u8* uSTxBufAddr = (u8*)SPI_getBuffer(0, TRUE, TRUE);
	u8* uSRxBufAddr = (u8*)SPI_getBuffer(1, FALSE, TRUE);

	DataCnt = SPI_DATA_COUNT;

// =========== SPI0 Slave Rx/Tx Setting =========== 
	printf( "SPI_BtoBSlaveFullDuplex\n");
	ch = SPI_open( TEST_CHANNEL0, SPI_SLAVE, SPI_TEST_CPOL, SPI_TEST_FORMAT, CLK_SOURCE, SPI_SPEED, SPI_TEST_CHANNEL_WIDTH, SPI_TEST_BUS_WIDTH, SPI_TEST_DMA_TYPE );
	SPI_transaction( ch, SPI_DMA_MODE, uSTxBufAddr, NULL, DataCnt, NULL);
	SPI_close( ch );

	if ( SPI_CompareData( uSTxBufAddr, uSRxBufAddr, DataCnt ) > 0 ) {
		return FALSE;
	}
	return TRUE;
}

//////////
// File Name : SPI_AgingTest
// File Description : Loopback Aging test.
// Input : NONE
// Output : NONE.
// Version : 
void SPI_AgingTest(void) {
	int i;
	int errorCnt=0;
	for (i=0;i<0x200000;i++) {
		if ( SPI_MasterFullDuplex() == FALSE ) {
			errorCnt++;
		}
		if ( SPI_SlaveFullDuplex() == FALSE ) {
			errorCnt++;
		}
		if ( errorCnt > 0 ) {
			printf( "------------------------ErrorCnt : [%d]------------------- \n ", errorCnt );
		}
	}
}

//////////
// File Name : SPI_AgingPollingTest
// File Description : Loopback Aging Test using Polling mode.
// Input : NONE
// Output : NONE.
// Version : 
void SPI_AgingPollingTest(void) {
	int i;
	int errorCnt=0;
	for (i=0;i<0x200000;i++) {
		if ( SPI_MasterTxOnly() == FALSE ) {
			errorCnt++;
		}
		if ( SPI_MasterRxOnly() == FALSE ) {
			errorCnt++;
		}
		if ( errorCnt > 0 ) {
			printf( "------------------------ErrorCnt : [%d]------------------- \n ", errorCnt );
		}
	}
}

testFuncMenu func_HSPI_test[]=
{
	(void(*)(void))SPI_MasterFullDuplex, 		"B2B Master Full Duplex   ",	
	(void(*)(void))SPI_SlaveFullDuplex,			"B2B Slave Full Duplex    ",
	(void(*)(void))SPI_MasterTxOnly,			"B2B Master Tx only       ",
	(void(*)(void))SPI_SlaveRxOnly,   			"B2B Slave Rx only         ",
	(void(*)(void))SPI_MasterRxOnly,			"B2B Master Rx only       ",
	(void(*)(void))SPI_SlaveTxOnly,   			"B2B Slave Tx only         ",	
	(void(*)(void))SPI_SwapMasterTxOnly,		"SPI_SwapMasterTxOnly ",
	(void(*)(void))SPI_BtoBMasterFullDuplex,	"SPI_BtoBMasterFullDuplex",
	(void(*)(void))SPI_BtoBSlaveFullDuplex,	"SPI_BtoBSlaveFullDuplex",
	(void(*)(void))SPI_AgingTest,				"SPI_AgingTest           ",
	(void(*)(void))SPI_AgingPollingTest,		"SPI_AgingPollingTest   ",
	(void(*)(void))SPI_DMA_periToPeriTest,		"SPI_DMA_periToPeriTest  ",
//	SPI_ErrorInterrutStaus,		"SPI_ErrorInterrutStaus   ",
	NULL,NULL
};

//////////
// File Name : Test_HSPI
// File Description : High-speed SPI Test function.
// Input : NONE
// Output : NONE.
// Version : 
void Test_HSPI(void)
{  
	int i;

	SYSC_SetLockTime( eEPLL, 300);
	SYSC_CtrlCLKOUT(eCLKOUT_EPLLOUT, 0);
	SYSC_SetPLL(eEPLL, 100, 3, 2, 0);		// EPLL => 100MHz
	Outp32( 0x7E00F01C, 7 );
	// youngbo.song Test.
	*((volatile u32*)0x7E00F900) |= (1<<16);	// USB Phi ON.
/*
	// 1. SPI EPLL Source-Setting.
	*((volatile u32*)0x7E00F01C) &= ~(0xF<<14);	// Clear
	//     Channel 1
	*((volatile u32*)0x7E00F01C) |= (0x0<<16);
	//     Channel 0
	*((volatile u32*)0x7E00F01C) |= (0x0<<14);

	// 2. SPI EPLL Ratio-Setting.
	*((volatile u32*)0x7E00F028) &= ~(0xFF<<0);	// Clear
	// Channel 1
	*((volatile u32*)0x7E00F028) |= (0x0<<4);
	// Channel 0
	*((volatile u32*)0x7E00F028) |= (0x0<<0);
*/
	// 3. SPI PCLK-Gate
	//     Channel 0
//	*((volatile u32*)0x7E00F034) &= ~(0x1<<21);
	//     Channel 1
//	*((volatile u32*)0x7E00F034) &= ~(0x1<<22);

	// 4. SPI SCLK- Gate
	//     SCLK_SPI1_48
//	*((volatile u32*)0x7E00F038) &= ~(0x1<<23);
	//     SCLK_SPI0_48
//	*((volatile u32*)0x7E00F038) &= ~(0x1<<22);
	//     SCLK_SPI1
//	*((volatile u32*)0x7E00F038) &= ~(0x1<<21);
	//     SCLK_SPI0
//	*((volatile u32*)0x7E00F038) &= ~(0x1<<20);
	
	while(1)
	{
		i=0;
		printf("\n\n");
		while(1)
		{   //display menu
	   		printf("%2d:%s", i, func_HSPI_test[i].desc);
	    	i++;
	    	if((func_HSPI_test[i].func)==NULL)
	    	{
				printf("\n");
				break;
	    	}
	    	if((i%2)==0)
	    	printf("\n");
		}

		printf("\nSelect (\"-1\" to exit) : ");
		i = GetIntNum();
		if(i==-1) 
	   		break;		// return.
		if( (i<((sizeof(func_HSPI_test)-1)/8)) )	// select and execute...
	    	( (void (*)(void)) (func_HSPI_test[i].func) )();
	}
	
}