spi.c

三星2413芯片的测试代码,对进行驱动开发很有帮助.

			}
			else {
				tx_buf = (unsigned char*)0x59000114;
			}
		}
		incDISRCC = 1;
		incDIDSTC = 0;
	}

	pDMA->DISRC=(unsigned)tx_buf;
	pDMA->DISRCC=(incDISRCC<<1)|(incDISRCC<<0); // AHB, INC or APB, fixed
	pDMA->DIDST=(unsigned)rx_buf;
	pDMA->DIDSTC=(incDIDSTC<<1)|(incDIDSTC<<0); // AHB, INC or APB, fixed

	if ( rxtx == SPI_TX ) {
		if ( withFIFO == TRUE ) {
			pDMA->DCON=(1<<31)|(0<<30)|(1<<29)|(1<<28)|(0<<27)|(0<<24)|(1<<22)|(0<<20)|(tc);
			                    //HS|AHB|InterruptEn|TransferSize|SingleServ|RelaodOff|DataSize|TransferCount
		}
		else {
			pDMA->DCON=(1<<31)|(0<<30)|(1<<29)|(0<<28)|(0<<27)|(0<<24)|(1<<22)|(0<<20)|(tc);
					   //HS|AHB|InterruptEn|TransferSize|SingleServ|RelaodOff|DataSize|TransferCount
		}
	}
	else {
		if ( withFIFO == TRUE ) {
			pDMA->DCON=(1<<31)|(0<<30)|(1<<29)|(1<<28)|(0<<27)|(1<<24)|(1<<22)|(0<<20)|(tc);
			                    //HS|AHB|InterruptEn|TransferSize|SingleServ|RelaodOff|DataSize|TransferCount
		}
		else {
			pDMA->DCON=(1<<31)|(0<<30)|(1<<29)|(0<<28)|(0<<27)|(0<<24)|(1<<22)|(0<<20)|(tc);
					   //HS|AHB|InterruptEn|TransferSize|SingleServ|RelaodOff|DataSize|TransferCount
		}
	}
	pDMA->DMAREQSEL=(dma_request_source<<1)|(1<<0);; //S/W request mode
	pDMA->DMASKTRIG=(0<<2)|(1<<1)|(0);    			//run, DMA1 channel on, no-sw trigger 
}

void spi_port_setting( SPI_port* port , SPI_who who, SPI_mode mode, SPI_channel channel, int withFIFO ) {
	int i,a;
	memset ( port, 0, sizeof(SPI_port) );

	if( mode == SPI_DMA_RX)
		mode == SPI_POLLING;
	
	if( who == SPI_MASTER ) {
//		port->spi_con.tx_fifo = (withFIFO == TRUE) ? (1) : (0);
		port->spi_con.direction = SPI_TX;
		port->spi_con.mode = mode;
		port->spi_con.who_sck_en = SPI_MASTER;
		port->spi_con.who_MSTR = SPI_MASTER;
		port->spi_con.clock_CPOL = SPI_CLOCK_LOW;
		port->spi_con.format_CPHA = SPI_FORMAT_A;
		port->spi_con.garbage_TAGD = SPI_AUTO_GARBAGE;

		port->spi_pin_con.feedback_clk_en = SPI_FEEDBACK_ENABLE;
		port->spi_pin_con.err_detect = SPI_MULTI_MASTER_ERR_DETECT_DISABLE;
		port->spi_pin_con.cs_out = SPI_CS_ACTIVE;
		port->spi_pin_con.out_keep = SPI_MASTER_OUT_KEEP_DRIVE;
		
		if ( withFIFO == TRUE ) {
			if ( channel == SPI_CHANNEL0 ) {
				rSPFIC0=(2<<8);					// TX FIFO DMA Ctl(Tx Fifo Empty)
			}
			else {
				rSPFIC1=(2<<8);
			}
		}
		else {
	//		rSPFIC0 = 0;
	//		rSPFIC1 = 0;
		}
	}
	else {
		// strange code.
#if 0
		if ( SPI_DMA_RX == mode )
			port->spi_con.direction = SPI_RX;
		else
			port->spi_con.direction = SPI_TX;
#else
		port->spi_con.direction = SPI_RX;
#endif
//		port->spi_con.rx_fifo = (withFIFO == TRUE) ? (1) : (0);
		port->spi_con.mode = mode;
		port->spi_con.who_sck_en = SPI_SLAVE;
		port->spi_con.who_MSTR = SPI_SLAVE;
		port->spi_con.clock_CPOL = SPI_CLOCK_LOW;
		port->spi_con.format_CPHA = SPI_FORMAT_A;
		port->spi_con.garbage_TAGD = SPI_AUTO_GARBAGE;

		port->spi_pin_con.feedback_clk_en = SPI_FEEDBACK_ENABLE;
		port->spi_pin_con.err_detect = SPI_MULTI_MASTER_ERR_DETECT_DISABLE;
		port->spi_pin_con.cs_out = SPI_CS_INACTIVE;
		port->spi_pin_con.out_keep = SPI_MASTER_OUT_KEEP_RELEASE;

		if ( withFIFO == TRUE ) {
			if ( channel == SPI_CHANNEL0 ) {
				rSPFIC0=(2<<10);					// RX FIFO DMA Ctl(Rx Almost Full)
			}
			else {
				rSPFIC1=(2<<10);
			}
		}
		else {
	//		rSPFIC0 = 0;
	//		rSPFIC1 = 0;
		}
	}

	if ( channel == SPI_CHANNEL0 ) {
		rSPCON0=*(unsigned int*)&port->spi_con;
		rSPPIN0=*(unsigned int*)&port->spi_pin_con;
	}
	else {
		rSPCON1=*(unsigned int*)&port->spi_con;
		rSPPIN1=*(unsigned int*)&port->spi_pin_con;
	}
#if 1
	if ( withFIFO == TRUE ) {
		if ( channel == SPI_CHANNEL0 ) {
			while ( (rSPSTA0>>3)&0x1 == 0 );
			rSPCON0|=(1<<8)|(1<<9);
			while ( (rSPSTA0>>3)&0x1 == 0 );
			rSPCON0|=(1<<11)|(1<<10);			// FIFO Clear
			while((rSPCON0>>10)&0x3 != 0);	// Wait for FIFO clear
		}
		else {
			while ( (rSPSTA1>>3)&0x1 == 0 );
			rSPCON1|=(1<<8)|(1<<9);
			while ( (rSPSTA1>>3)&0x1 == 0 );
			rSPCON1|=(1<<11)|(1<<10);			// FIFO Clear
			while((rSPCON1>>10)&0x3 != 0);	// Wait for FIFO clear
		}
	}
#endif
}

unsigned char* getBuffer( SPI_channel channel, SPI_direction rxtx, int mode ) {
	unsigned char * addr = (unsigned char*)_NONCACHE_STARTADDRESS, *temp;
	int offset = 0;
	int i;

	offset = channel * RXTX_SIZE * 2;
	offset = offset + rxtx* RXTX_SIZE;

	addr = addr + offset;

	if ( mode == 1 ) {
		memset ( addr, 0, RXTX_SIZE );
	}
	else if ( mode == 2 ) {
		temp = addr;	// 93
		for ( i = 0; i < RXTX_SIZE ; i++ ) {
			*temp++ = i%93 + 33;
		}
	}
	
	return addr;
}


void SPI_slave_FIFO_DMA_master_polling_test(void) {
	SPI_port port0, port1;
	int i, a,b;
	int dmachannel = 0;
	SPI_channel ch_slave = SPI_CHANNEL0;
	SPI_channel ch_master = SPI_CHANNEL1;

	printf( "One-Board Test for Functional Verification\n" );
	printf( "Master SPI1 Channel, Slave SPI0 Channel\n" );
	printf( "Master is FIFO DMA mode, Slave is FIFO mode \n");

	tx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_TX, 2 );
	rx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_RX, 1 );
	tx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_TX, 2 );
	rx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_RX, 1 );

	SPI_Port_Init(ch_master);
	SPI_Baud_Rate_Set(ch_master, SPI_CLOCK);			// SPI Channel 0, 25MHz
	SPI_Baud_Rate_Set(ch_slave, SPI_CLOCK);

	spi_port_setting( &port0, SPI_MASTER, SPI_POLLING, ch_master, FALSE );
	spi_port_setting( &port1, SPI_SLAVE, SPI_POLLING, ch_slave, TRUE );
  
	Test_Spi_DMA_Set( dmachannel, ch_slave, tx_ptr[ch_slave], rx_ptr[ch_slave], SPI_RX, TRUE);
	
	while(spi_dma_done[dmachannel] != 1) {
		a=1;
		while ( a==1 ) {
			if ( a == 1 && REDY1 == 1 ) {
				WrSPTDAT1(*tx_ptr[ch_master]++);
				a = 0;
			}
		}
	}
	
	spi_release_transmission( SPI_CHANNEL0 );
	spi_release_transmission( SPI_CHANNEL1 );

	pISR_DMA0=(int)0;
	pISR_DMA1=(int)0;
	rINTMSK|=(BIT_DMA0)|(BIT_DMA1);

	rx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_RX, 0 );
	rx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_RX, 0 );
	tx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_TX, 0 );
	tx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_TX, 0 );
	if(memcmp( rx_ptr[ch_slave]+1, tx_ptr[ch_master]+1, RXTX_SIZE-10)==0)
		printf("O.K.\n");
	else
		printf("ERROR!!!\n");

	SPI_Port_Return();
}

void SPI_master_FIFO_DMA_slave_polling_test(void) {
	SPI_port port0, port1;
	int a;
	int dmachannel = 0;
	SPI_channel ch_slave = SPI_CHANNEL1;
	SPI_channel ch_master = SPI_CHANNEL0;
	register unsigned char * rx;

	printf( "One-Board Test for Functional Verification\n" );
	printf( "Master SPI0 Channel, Slave SPI1 Channel\n" );
	printf( "Master is FIFO DMA mode, Slave is FIFO mode \n");
	
	tx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_TX, 2 );
	rx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_RX, 1 );
	tx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_TX, 2 );
	rx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_RX, 1 );

	SPI_Port_Init(SPI_CHANNEL0);
	SPI_Baud_Rate_Set(SPI_CHANNEL0, SPI_CLOCK);			// SPI Channel 0, 25MHz
	SPI_Baud_Rate_Set(SPI_CHANNEL1, SPI_CLOCK);
	
	spi_port_setting( &port0, SPI_MASTER, SPI_DMA_TX, ch_master, TRUE );
	spi_port_setting( &port1, SPI_SLAVE, SPI_POLLING, ch_slave, FALSE);
	rx = rx_ptr[ch_slave];
	Test_Spi_DMA_Set( dmachannel, ch_master, tx_ptr[ch_master], rx_ptr[ch_master], SPI_TX, TRUE);
	
	while(spi_dma_done[dmachannel] != 1) {
#if 0
		a=1;
		while ( a==1 ) {
			if ( a == 1 && REDY1 == 1 ) {
				WrSPTDAT1(*tx_ptr[ch_slave]++);
				a = 0;
			}
		}

		while ( a==0 ) {
			if ( a == 0 && REDY1 == 1 ) {
				*rx_ptr[ch_slave]++=RdSPRDAT1();
				a = 1;
			}
		}
#else
		if ( REDY1 == 1 ) {
			*rx++=RdSPRDAT1();
		}
#endif
	}
	
	spi_release_transmission( SPI_CHANNEL0 );
	spi_release_transmission( SPI_CHANNEL1 );
	rx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_RX, 0 );
	rx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_RX, 0 );
	tx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_TX, 0 );
	tx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_TX, 0 );
	if(memcmp( tx_ptr[ch_master]+18, rx_ptr[ch_slave]+2, RXTX_SIZE-50)==0)
		printf("O.K.\n");
	else {
		printf("ERROR!!!\n");
	}

	SPI_Port_Return();
}

void SPI_slave_DMA_master_polling_test(void) {
	SPI_port port0, port1;
	int a;
	int dmachannel = 0;
	SPI_channel ch_slave = SPI_CHANNEL0;
	SPI_channel ch_master = SPI_CHANNEL1;

	printf( "One-Board Test for Functional Verification\n" );
	printf( "Master SPI1 Channel, Slave SPI0 Channel\n" );
	printf( "Master is polling mode, Slave is DMA mode \n");

	tx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_TX, 2 );
	rx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_RX, 1 );
	tx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_TX, 2 );
	rx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_RX, 1 );

	SPI_Port_Init(ch_master);
	SPI_Baud_Rate_Set(ch_slave, SPI_CLOCK);			// SPI Channel 0, 25MHz
	SPI_Baud_Rate_Set(ch_master, SPI_CLOCK);

	spi_port_setting( &port0, SPI_MASTER, SPI_POLLING, ch_master, FALSE );
	spi_port_setting( &port1, SPI_SLAVE, SPI_DMA_RX, ch_slave, FALSE );
	Test_Spi_DMA_Set( dmachannel, ch_slave, tx_ptr[ch_slave], rx_ptr[ch_slave], SPI_RX, FALSE);

	while(spi_dma_done[dmachannel] != 1) {
		a=1;
		while ( a==1 ) {
			if ( a == 1 && REDY1 == 1 ) {
				WrSPTDAT1(*tx_ptr[ch_master]++);
				a = 0;
			}
		}
	}
	
	spi_release_transmission( ch_master );
	spi_release_transmission( ch_slave );
	rx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_RX, 0 );
	rx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_RX, 0 );
	tx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_TX, 0 );
	tx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_TX, 0 );
	if(memcmp( rx_ptr[ch_slave]+3, tx_ptr[ch_master]+1, RXTX_SIZE-10)==0)
		printf("O.K.\n");
	else
		printf("ERROR!!!\n");

	SPI_Port_Return();
}

void SPI_master_DMA_slave_polling_test(void) {
	SPI_port port0, port1;
	int a;
	int dmachannel = 0;
	SPI_channel ch_slave = SPI_CHANNEL0;
	SPI_channel ch_master = SPI_CHANNEL1;
	register unsigned char * rx;

	printf( "One-Board Test for Functional Verification\n" );
	printf( "Master SPI1 Channel, Slave SPI0 Channel\n" );
	printf( "Master is DMA mode, Slave is Polling mode \n");
	
	tx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_TX, 2 );
	rx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_RX, 1 );
	tx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_TX, 2 );
	rx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_RX, 1 );

	SPI_Port_Init(SPI_CHANNEL0);
	SPI_Baud_Rate_Set(SPI_CHANNEL0, SPI_CLOCK);			// SPI Channel 0, 25MHz
	SPI_Baud_Rate_Set(SPI_CHANNEL1, SPI_CLOCK);

	rx=rx_ptr[ch_slave];
	spi_port_setting( &port0, SPI_MASTER, SPI_DMA_TX, ch_master, FALSE );
	spi_port_setting( &port1, SPI_SLAVE, SPI_POLLING, ch_slave, FALSE );
	Test_Spi_DMA_Set( dmachannel, ch_master, tx_ptr[ch_master], rx_ptr[ch_master], SPI_TX, FALSE);

	while(spi_dma_done[dmachannel] != 1)
	{
#if 0
		a=1;
		while ( a==1 ) {
			if ( a == 1 && REDY0 == 1 ) {
				WrSPTDAT0(*tx_ptr[ch_slave]++);
				a = 0;
			}
		}

		while ( a==0 ) {
			if ( a == 0 && REDY0 == 1 ) {
				*rx_ptr[ch_slave]++=RdSPRDAT0();
				a = 1;
			}
		}
#else
		if ( REDY0 == 1 ) {
			*rx++=RdSPRDAT0();
		}
#endif
	}
	
	spi_release_transmission( SPI_CHANNEL0 );
	spi_release_transmission( SPI_CHANNEL1 );
	rx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_RX, 0 );
	rx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_RX, 0 );
	tx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_TX, 0 );
	tx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_TX, 0 );
	if(memcmp( tx_ptr[ch_master]+1, rx_ptr[ch_slave]+2, 0xf0)==0 ||
		memcmp( tx_ptr[ch_master]+1, rx_ptr[ch_slave]+1, 0xf0)==0)
		printf("O.K.\n");
	else {
		printf("ERROR!!!\n");
	}

	SPI_Port_Return();
}

void SPI_slave_int_master_polling_test( void ) {
	SPI_port port0, port1;
	int i=0,a;

	printf( "One-Board Test for Functional Verification\n" );
	printf( "Master SPI1 Channel, Slave SPI0 Channel\n" );
	printf( "Master is interrupt mode, Slave is Polling mode \n");
	
	interrupt_count[0] = interrupt_count[1] = 0;
	tx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_TX, 2 );
	rx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_RX, 1 );
	tx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_TX, 2 );
	rx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_RX, 1 );
	
	SPI_Port_Init(SPI_CHANNEL1);
	SPI_Baud_Rate_Set(SPI_CHANNEL0, SPI_CLOCK);			// SPI Channel 0, 25MHz
	SPI_Baud_Rate_Set(SPI_CHANNEL1, SPI_CLOCK);

	spi_port_setting( &port0, SPI_SLAVE, SPI_INT, SPI_CHANNEL0, FALSE );
	pISR_SPI0=(unsigned)spi_slave_int0;
	rINTMSK&=~(BIT_SPI0);
// -------master-------------------
	spi_port_setting( &port1, SPI_MASTER, SPI_POLLING, SPI_CHANNEL1, FALSE );

	while(1)
	{
		a=1;
		while ( a==1 ) {
			if ( a == 1 && REDY1 == 1 ) {
				WrSPTDAT1(*tx_ptr[1]++);
				a = 0;
			}
		}

		while ( a==0 ) {
			if ( a == 0 && REDY1 == 1 ) {
				*rx_ptr[1]++=RdSPRDAT1();
				a = 1;
			}
		}
		
		if ( ++i >= RXTX_SIZE )
			break;
	}

	rINTMSK|=(BIT_SPI0);
	spi_release_transmission( SPI_CHANNEL0 );
	spi_release_transmission( SPI_CHANNEL1 );

	tx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_TX, 0 );
	rx_ptr[SPI_CHANNEL0] = getBuffer( SPI_CHANNEL0, SPI_RX, 0 );
	tx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_TX, 0 );
	rx_ptr[SPI_CHANNEL1] = getBuffer( SPI_CHANNEL1, SPI_RX, 0 );
	if(memcmp( rx_ptr[SPI_CHANNEL0]+2, rx_ptr[SPI_CHANNEL1]+1, RXTX_SIZE-10)==0)
		printf("O.K.\n");
	else
		printf("ERROR!!!\n");

	SPI_Port_Return();
	printf("int count %d, %d \n",interrupt_count[0], interrupt_count[1]);
}


void SPI_slave_polling_master_polling_test_FIFO(void) {
	unsigned char *tx0,*rx0, *tx1, *rx1;
	SPI_port port0, port1;
	int i=0, a,b;

	printf( "One-Board Test for Functional Verification\n" );
	printf( "Master SPI1 Channel, Slave SPI0 Channel\n" );
	printf( "Master is polling with fifo mode, Slave is Polling with fifo mode \n");

	tx0 = getBuffer( SPI_CHANNEL0, SPI_TX, 2 );
	rx0 = getBuffer( SPI_CHANNEL0, SPI_RX, 1 );
	tx1 = getBuffer( SPI_CHANNEL1, SPI_TX, 2 );
	rx1 = getBuffer( SPI_CHANNEL1, SPI_RX, 1 );
	
	SPI_Port_Init(SPI_CHANNEL0);
	SPI_Baud_Rate_Set(SPI_CHANNEL0, SPI_CLOCK);			// SPI Channel 0, 25MHz
	SPI_Baud_Rate_Set(SPI_CHANNEL1,