sdi.c

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

#include <stdio.h>
#include <string.h>
#include "def.h"
#include "option.h"
#include "2413addr.h"
#include "console.h"
#include "system.h"
#include "sdi.h"
#include "timer.h"

#define INICLK	400000
#define SDCLK	25000000	
//#define MMCCLK	17 500 000
#define MMCCLK	20000000
#define MOVICLK  25000000
//#define MMCCLK	17500000

#define POL	0
#define INT	1
#define DMA	2
#define SDI_Tx_buffer (_NONCACHE_STARTADDRESS)
#define SDI_Rx_buffer (_NONCACHE_STARTADDRESS+(0x800000))


#define Card_OneBlockSize 512

void __irq DMA_end(void);

// Global variables
unsigned int *Tx_buffer;	//128[word]*16[blk]=8192[byte]
unsigned int *Rx_buffer;	//128[word]*16[blk]=8192[byte]
volatile unsigned int rd_cnt;
volatile unsigned int wt_cnt;
volatile unsigned int BlockNum=0;
volatile unsigned int TR_end=0;

CardType card_type;
U32 Wide=0; // 0:1bit, 1:4bit
//U32 MMC=0;  // 0:SD  , 1:MMC

int  Maker_ID;
char Product_Name[7]; 
int  Serial_Num;

volatile int RCA;

void * func_sdio_test[][2]=
{
	(void *)SDIO_WriteTest, "SDIO Write          ",
	(void *)SDIO_ReadTest, "SDIO Read           ",
	(void *)SDIO_EraseBlock, "SDIO Block Erase    ",
	(void *)writeBigSizeIOTest, "writeBigSizeIOTest      ",
	(void *)readBigSizeIOTest, "readBigSizeIOTest    ",
	(void *)writeBigSizeIOTestRnd, "writeBigSizeIOTestRnd  ",
	(void *)readBigSizeIOTestRnd, "readBigSizeIOTestRnd  ",
	(void *)rwBigSigeIOTestRnd, "rwBigSigeIOTestRnd  ",
	(void *)stream_write_test, "stream_write_test   ",
	(void *)stream_read_test, "stream_read_test   ",
	0,0
};

void Ch18_Sdmmc(void)
{  
	int i;
	RCA=0;
	card_type=SD_CARD;
	//block=16;   //3072Blocks=1.5MByte, ((2Block=1024Byte)*1024Block=1MByte)

	SD_MMC_SETGPIO();

	printf("\n[SDI test]\n");   

	if(!SD_card_init()) {
		printf("\nCard initial fail\n");
	}
	
	if(card_type==SD_CARD)
		printf("\n[SD card test...PCLK:%d,INICLK:%d,SDCLK:%d]\n",PCLK,INICLK,SDCLK); 
	else if(card_type==MMC_CARD)
		printf("\n[MMC card test...PCLK:%d,INICLK:%d,MMCCLK:%d]\n",PCLK,INICLK,MMCCLK);
	else if(card_type==MOVI_NAND_CARD)
		printf("\n[MMC card test...PCLK:%d,INICLK:%d,MOVICLK:%d]\n",PCLK,INICLK,MOVICLK);
	
/*	while(1)
	{
		i=0;
		printf("\n\n");
		while(1)
		{   //display menu
			printf("%2d:%s",i,func_sdio_test[i][1]);
			i++;
			if((int)(func_sdio_test[i][0])==0)
			{
				printf("\n");
				break;
			}
			if((i%3)==0)
				printf("\n");
		}

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

void SD_MMC_SETGPIO(void)
{
	rGPECON = (rGPECON& ~(0x3ffc00))|(0x1<<21)|(0x1<<19)|(0x1<<17)|(0x1<<15)|(0x1<<13)|(0x1<<11);
}

void SDIO_ReadTest(void)
{
	U32 i, StartAddr, OneBlockSize, Testmode, Addr_temp;
	unsigned int time;

	rd_cnt=0;	

	printf("\nSD/MMC block Read test\n");

	printf("\nInput Read Start Address : ");
	StartAddr = GetIntNum();
	Addr_temp = StartAddr;
	
	while((BlockNum == 0) || (BlockNum > 4096))
	{
		printf("Input Read Block Number[1~4096] : ");
		BlockNum = GetIntNum();
	}

	OneBlockSize = Card_OneBlockSize;

	Rx_buffer = (U32 *)SDI_Rx_buffer;
    	for(i=0 ; i<(OneBlockSize*BlockNum)/4 ; i++)	
		*(Rx_buffer+i) = 0x0;    

	//rSDIDSTA |= (1<<7)|(1<<6)|(1<<5)|(1<<4)|(1<<3)|(1<<2);
	rSDIDSTA = CRC_STAT_FAIL|RECEIVE_CRC_FAIL|DATA_TOUT|DATA_FINISH|BUSY_FINISH;
	rSDIDCON = 0;

	rSDIFSTA |= (1<<16);	//FIFO reset

	if(Wide==0)
		rSDIDCON &= ~WIDE_BUS_EN;
	else
		rSDIDCON |= WIDE_BUS_EN;	

	rSDIDCON |=WORD_TRANSFER|RCV_AFTER_CMD|BLOCK_TRANSFER|BlockNum;
	rSDIDCON |= DATA_RECEIVE_MODE|DATA_TRANSMIT_START;

	printf("\n0:Polling read   1:Interrupt read   2:DMA read");
	printf("\nSelect the test mode : ");
    
       Testmode=GetIntNum();

	Timer_Start(3);//128us resolution      
    
	switch(Testmode)
	{
		case  POL:
			if(BlockNum<2)	
			{
				do { 		// StartAddr * 512
					SDIO_Command(StartAddr<<9, READ_SINGLE_BLOCK_CMD, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
				} while(Check_CMDend(READ_SINGLE_BLOCK_CMD, 1) != 1)	;
				//printf("CMD READ_SINGLE_BLOCK_CMD passed\n");
			}
			else	
			{
				do {
					SDIO_Command(StartAddr<<9, READ_MULTIPLE_BLOCK_CMD, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
				} while(Check_CMDend(READ_MULTIPLE_BLOCK_CMD, 1) != 1)	;
				//printf("CMD READ_MULTIPLE_BLOCK_CMD passed\n");
			}

			rSDICSTA = DATA_TIMEOUT|CMD_END|RESP_END;	// Clear cmd_end(with rsp)
			//printf("\nData status=%x",rSDICSTA);

//			printf("\nTotal size =%x",OneBlockSize*BlockNum/4);
			while(rd_cnt<(OneBlockSize*BlockNum)/4)	
			{
				if(rSDIDSTA & DATA_TOUT) // Check timeout 
				{
					printf("\nData status=%x",rSDICSTA);
					rSDIDSTA |= DATA_TOUT;  // Clear timeout flag
					break;
				}
	
//				status = rSDIFSTA;	//If FIFO is not empty, receive data from Data Register(rSDIDAT0)
				if(rSDIFSTA& RX_FIFO_AVAILABLE_DETECT)	// Is Rx data?
				{
					*Rx_buffer++ = rSDIDAT;
					rd_cnt++;
				}
			}

//			printf("\nRead Count =%x",rd_cnt);
			break;

		case INT:
			pISR_SDI_CF=(unsigned)Rd_Int;
			
		    	if(BlockNum<2)
			{
				do {// StartAddr * 512
					SDIO_Command(StartAddr<<9, READ_SINGLE_BLOCK_CMD, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
				} while(Check_CMDend(READ_SINGLE_BLOCK_CMD, 1) != 1);
			}
			else	
			{
				do {
					SDIO_Command(StartAddr<<9, READ_MULTIPLE_BLOCK_CMD, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
				} while(Check_CMDend(READ_MULTIPLE_BLOCK_CMD, 1) != 1);
			}
    			rSDICSTA = DATA_TIMEOUT|CMD_END|RESP_END;	// Clear cmd_end(with rsp)
    			
			rINTMSK &= ~(BIT_SDI_CF);
			rINTSUBMSK &=~(BIT_SUB_SDI);
			rSDIIMSK=0x5;	// Last & Rx FIFO half int.

    			while(rd_cnt<(Card_OneBlockSize/4)*BlockNum) {
    				printf ( "Interrupt Source Pending:0x%x\n", *((unsigned int*)rSRCPND));
    			}

    			rINTMSK |= (BIT_SDI_CF);
    			rSDIIMSK=0;	// All mask
    			break;
		case DMA:
//			printf("\nDMA mode data write\n");

			pISR_DMA0=(unsigned)DMA_end;
    			rINTMSK&=~(BIT_DMA0);
			//rINTSUBMSK&=~(BIT_SUB_DMA0);

  		    	rDISRC0 = (U32)(SDIDAT);
		    	rDISRCC0 = (1<<1) | (1<<0);
			rDIDST0 = (int)(Rx_buffer);
			rDIDSTC0 = (0<<1)|(0<<0);
			rDCON0 = (1<<31)|(0<<30)|(1<<29)|(1<<28)|(0<<27)|(1<<24)|(1<<22)|(2<<20) | (128*BlockNum)/4;
			rDMASKTRIG0 = (0<<2)|(1<<1)|0;    //no-stop, DMA0 channel on, no-sw trigger
			rDMAREQSEL0 = (10 <<1) | 1;

    			if(BlockNum<2)	
			{
				do {// StartAddr * 512
					SDIO_Command(StartAddr<<9, READ_SINGLE_BLOCK_CMD, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
				} while(Check_CMDend(READ_SINGLE_BLOCK_CMD, 1) != 1)	;
			}
			else	
			{
				do {
					SDIO_Command(StartAddr<<9, READ_MULTIPLE_BLOCK_CMD, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
				} while(Check_CMDend(READ_MULTIPLE_BLOCK_CMD, 1) != 1)	;
			}

    			rSDICSTA = DATA_TIMEOUT|CMD_END|RESP_END;	// Clear cmd_end(with rsp)

			rSDIDCON |=BURST4_EN|WORD_TRANSFER|RCV_AFTER_CMD|BLOCK_TRANSFER|DMA_EN|BlockNum;
			rSDIDCON |= DATA_RECEIVE_MODE|DATA_TRANSMIT_START;

			if(Wide!=0)
				rSDIDCON |= WIDE_BUS_EN;
			else
				rSDIDCON &= ~WIDE_BUS_EN;
			
    			while(!TR_end);
			rINTMSK |= (BIT_DMA0);
			//rINTSUBMSK |= (BIT_SUB_DMA0);
    			TR_end=0;
    			rDMASKTRIG0=(1<<2);	//DMA0 stop
			
		default : break;	
	}

//	time=Timer_Stop();
	
	if(!Check_DATend()) 
		printf("\nData End Error....\n");


 	if(BlockNum>1)
	{
		do {
			SDIO_Command(0, STOP_TRANSMISSION_CMD, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
		} while(Check_CMDend(STOP_TRANSMISSION_CMD, 1) != 1);
		rSDICSTA = CMD_END|RESP_END;;	// Clear cmd_end(with rsp)
	}

	Rx_buffer = (U32 *)SDI_Rx_buffer;

// print received data
/*	for(j=0 ; j<(OneBlockSize*BlockNum)/4 ; j++)
   	{
	      	if(j%4 == 0)
	   		printf("\n0x%04xh : ",Addr_temp);
	       	printf("0x%08x ",*Rx_buffer++);
	       	Addr_temp += 4;
	}
*/
	time=Timer_Stop();
	printf ("TIME is : %d us\n", time<<7); // time is 1/128 mux
	printf ( "Transfer Rate is : %f MB per sec \n", ((float)(BlockNum<<9)) / ((float)(time<<7)) );
	
	BlockNum = 0;
	printf("\n");    
}

void writeBigSizeIOTestRnd(void) {
	unsigned int time;
	int i,j,k,Offset=0;
	int StartAddr=0;
	int EndAddr=0;	// temp start address is zero.
	int OneBlockSize;
	unsigned int * sourceAddr;
	time = 0;
	BlockNum = 1;

	// 8(block count) * 256(k count) * 512(one block size) = 1Mb
	for (k=0;k<2999999;k++) {		// 100 MB
		StartAddr = (StartAddr * 32 + 17)%4000;
		EndAddr = StartAddr + 1;

	//	StartAddr = k*BlockNum;
		TR_end = 0;
		Tx_buffer = (U32 *)SDI_Tx_buffer;
	    	for(i=0 ; i<(Card_OneBlockSize/4*BlockNum) ; i++)
			*(Tx_buffer+i) = (i+Offset);

		rSDIFSTA |=(1<<16); //FIFO reset
		rSDIDCON=(2<<22)|(1<<20)|(1<<17)|(Wide<<16)|(1<<14)|(3<<12)|(BlockNum<<0);
		rSDIDCON|=BURST4_EN|WORD_TRANSFER|TRANS_AFTER_RESP|BLOCK_TRANSFER|DMA_EN|BlockNum;
		rSDIDCON|= DATA_TRANSMIT_MODE|DATA_TRANSMIT_START;
		if(Wide!=0)
			rSDIDCON |= WIDE_BUS_EN;
		else
			rSDIDCON &= ~WIDE_BUS_EN;

		pISR_DMA0=(unsigned)DMA_end;
		rINTMSK&=~(BIT_DMA0);
		//rINTSUBMSK&=~(BIT_SUB_DMA0);  

	    	rDISRC0 = (int)(Tx_buffer);	
	    	rDISRCC0 = (0<<1) | (0<<0);	
		rDIDST0 = (U32)(SDIDAT);	
		rDIDSTC0 = (1<<1)|(1<<0);	
		rDCON0 = (1<<31)|(0<<30)|(1<<29)|(1<<28)|(0<<27)|(1<<24)|(1<<22)|(2<<20) | (128*BlockNum)/4;
		rDMASKTRIG0 = (0<<2)|(1<<1)|0;    //no-stop, DMA0 channel on, no-sw trigger
		rDMAREQSEL0 = (10 <<1) | 1;
		Timer_Start(3);
		if(BlockNum<2)//single block
		{
			do {	// StartAddr * 512
				SDIO_Command(StartAddr<<9, WRITE_BLOCK_CMD, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITH_DATA);
			} while((Check_CMDend(WRITE_BLOCK_CMD, 1) !=1)); 
		}
		else//multi block
		{
			do {
				SDIO_Command(StartAddr<<9, WRITE_MULTIPLE_BLOCK, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITH_DATA);
			} while((Check_CMDend(WRITE_MULTIPLE_BLOCK, 1) !=1));
		}

		while(!TR_end);

		rINTMSK |= (1<<20);
		rINTSUBMSK |= (1<<27);
		TR_end=0;
		rDMASKTRIG0 |=(1<<2);//DMA Stop
		
		while(!Check_DATend2());
			//printf("\nData End Error\n");
		rSDIDCON=rSDIDCON&~(7<<12);		//YH 040220, Clear Data Transfer mode => no operation, Cleata Data Transfer start
		rSDIDSTA |= DATA_FINISH;	// Clear data Tx/Rx end

		if(BlockNum>1)
		{
			rSDIDCON=BUSY_AFTER_CMD|BLOCK_TRANSFER|WIDE_BUS_DIS|DATA_TRANSMIT_START|ONLYBUSY_CHECK|(BlockNum<<0); 	
			do {
				SDIO_Command(0, STOP_TRANSMISSION_CMD, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
			} while(Check_CMDend(12, 1) != 1)	;

			rSDICSTA = CMD_END|RESP_END;	// Clear cmd_end(with rsp)

			if(!Check_BUSYend()) 
				printf("error\n");

			rSDIDSTA|= DATA_FINISH;	//! Should be cleared by writing '1'.
		}
		time=time+Timer_Stop();

		// read and compare.-------------------------------------------------------------
#if 0
		OneBlockSize = Card_OneBlockSize;

		Rx_buffer = (U32 *)SDI_Rx_buffer;
	    	for(i=0 ; i<(OneBlockSize*BlockNum)/4 ; i++)
			*(Rx_buffer+i) = 0x0;

		//rSDIDSTA |= (1<<7)|(1<<6)|(1<<5)|(1<<4)|(1<<3)|(1<<2);
		rSDIDSTA = CRC_STAT_FAIL|RECEIVE_CRC_FAIL|DATA_TOUT|DATA_FINISH|BUSY_FINISH;
		rSDIDCON = 0;

		rSDIFSTA |= (1<<16);	//FIFO reset

		if(Wide==0)
			rSDIDCON &= ~WIDE_BUS_EN;
		else
			rSDIDCON |= WIDE_BUS_EN;	

		rSDIDCON |=WORD_TRANSFER|RCV_AFTER_CMD|BLOCK_TRANSFER|BlockNum;
		rSDIDCON |= DATA_RECEIVE_MODE|DATA_TRANSMIT_START;
		rSDIDCON |=BURST4_EN|WORD_TRANSFER|TRANS_AFTER_RESP|BLOCK_TRANSFER|DMA_EN;

		pISR_DMA0=(unsigned)DMA_end;
		rINTMSK&=~(BIT_DMA0);
		//rINTSUBMSK&=~(BIT_SUB_DMA0);

		rDISRC0 = (U32)(SDIDAT);
	    	rDISRCC0 = (1<<1) | (1<<0);
		rDIDST0 = (int)(Rx_buffer);
		rDIDSTC0 = (0<<1)|(0<<0);
		rDCON0 = (1<<31)|(0<<30)|(1<<29)|(1<<28)|(0<<27)|(1<<24)|(1<<22)|(2<<20) | (128*BlockNum)/4;
		rDMASKTRIG0 = (0<<2)|(1<<1)|0;    //no-stop, DMA0 channel on, no-sw trigger
		rDMAREQSEL0 = (10 <<1) | 1;

		do {// StartAddr * 512
			SDIO_Command(StartAddr<<9, READ_SINGLE_BLOCK_CMD, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITH_DATA);
		} while(Check_CMDend(READ_SINGLE_BLOCK_CMD, 1) != 1);

		rSDICSTA = DATA_TIMEOUT|CMD_END|RESP_END;	// Clear cmd_end(with rsp)

		while(!TR_end);

		rINTMSK |= (BIT_DMA0);
		//rINTSUBMSK |= (BIT_SUB_DMA0);
		TR_end=0;
		rDMASKTRIG0=(1<<2);	//DMA0 stop
		
		if(!Check_DATend()) 
			printf("\nData End Error....\n");

		sourceAddr = (unsigned int *)SDI_Tx_buffer;
		Rx_buffer = (U32 *)SDI_Rx_buffer;
		for(j=0 ; j<(OneBlockSize*BlockNum)/4 ; j=j+4)
	   	{
			if ( *Rx_buffer != *sourceAddr ) {
				printf ("data error : %x, source : %x \n" , *Rx_buffer, *sourceAddr);
			}
			Rx_buffer++;
			sourceAddr++;
		}
#endif
	}
	
	printf ("TIME is : %d us, Block Count:%d\n", time<<7, BlockNum);
	printf ( "Transfer Rate is : %f MB per sec \n", ((float)((BlockNum*k)<<9)) / ((float)(time<<7)) );
}


void readBigSizeIOTestRnd(void) {
	unsigned int time;
	int i,j,k,Offset=0;
	int StartAddr=0;
	int EndAddr=0;	// temp start address is zero.
	int OneBlockSize;
	unsigned int * sourceAddr;
	time = 0;
	BlockNum = 1;

	// 8(block count) * 256(k count) * 512(one block size) = 1Mb
	for (k=0;k<2999999;k++) {		// 100 MB