sdi.c

Samsung S3C2443 Test program source code

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

#define INICLK	400000
#define SDCLK	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

int CMD13(void);    // Send card status
int CMD9(void);
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 SD_MMC_Ins;
volatile unsigned int TR_end=0;

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_WriteReadTest,       	"SDIO Write & Read   ",
    (void *)SDIO_WriteTest,       	    "SDIO Write          ",
    (void *)SDIO_ReadTest,           	"SDIO Read           ",
    (void *)SDIO_EraseBlock,            "SDIO Block Erase    ",
    0,0
};

#if 0
void SD_MMC_Sub_Irq(void)
{

#if 0
	rGPCON_M= (rGPCON_M & 0xcfff)|(0x0<<12); //GPIO17 -> Input	
	if(rGPDAT & (1<<17) ) {
		printf("\nSD/MMC is extracted.\n");
		SD_MMC_Ins = 0;	
	} 
	else {
		printf("SD/MMC is inserted.\n");
		SD_MMC_Ins = 1;		
	}
	rGPCON_M= (rGPCON_M & 0xcfff)|(0x2<<12); //GPIO17 -> EINT17
	
#else
	rGPCON_L&=~(0x3<<14); //GPIO7 -> Input
	if(rGPDAT & (1<<7) ) {
		printf("\nT-Flash is inserted.\n");
		SD_MMC_Ins = 0;	
	} 
	else {
		printf("T-Flash is extracted.\n");
		SD_MMC_Ins = 1;		
	}
	rGPCON_L |=(0x2<<14); //GPIO7 -> EINT7
	
#endif
}


void __irq SD_MMC_EINT17_Irq(void)
{

	if(rEINTPEND==(1<<17))
		{
		//printf("EINT17 interrupt is occured\n");
		rEINTPEND=(1<<17);
		}
	else
		{
		printf("rEINTPEND=%x\n",rEINTPEND);
		rEINTPEND=(1<<17);
		}
	ClearPending(BIT_EINT15_18);
	
	SD_MMC_Sub_Irq();
	
	rEINTMASK=0xffffff;
	rINTMSK=BIT_ALLMSK;		
}


void Init_SD_MMC_CD_Irq(void)
{
	// Interrupt enable for SD/MMC insert interrupt.
	pISR_EINT15_18= (int)SD_MMC_EINT17_Irq;	// Set interrupt service routine.
	
	rGPCON_M= (rGPCON_M & 0xcfff)|(0x2<<12); //GPIO17 -> EINT17
	rEXTINTC2=rEXTINTC2 & ~(0xf<<24)|(0xf<<24); //filtering & Both edge triggered	
	
	rEINTPEND = 0xffffff;
	rSRCPND = BIT_EINT15_18; //to clear the previous pending states
	rINTPND = BIT_EINT15_18;
	rEINTMASK=~(1<<17);
	rINTMSK=~(BIT_EINT15_18);	
}

#endif

void Test_SDI(void)
{  
	int i;
    RCA=0;
    MMC=0;
    //block=16;   //3072Blocks=1.5MByte, ((2Block=1024Byte)*1024Block=1MByte)
    SD_MMC_Ins=0;    
	
    SD_MMC_SETGPIO();
    
    printf("\n[SDI test]\n");   

    if(!SD_card_init())
    	{
    		printf("\nCard initial fail\n");
    	}
	
    if(!MMC)
    printf("\n[SD card test...PCLK:%d,INICLK:%d,SDCLK:%d]\n",PCLK,INICLK,SDCLK); 
    else
    printf("\n[MMC card test...PCLK:%d,INICLK:%d,MMCCLK:%d]\n",PCLK,INICLK,MMCCLK);
	
	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, Offset, Testmode, Addr_temp;
	U32 status,transtime=0;
	int j;

	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();

	switch(Testmode)
		{
			case  POL:
					if(BlockNum<2)	
					{
						SDIO_Command((StartAddr*512), 17, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
						while(Check_CMDend(17, 1) != 1)								
						SDIO_Command((StartAddr*512), 17, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
						//printf("CMD 17 passed\n");
					}
					else	
					{
						SDIO_Command((StartAddr*512), 18, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
						while(Check_CMDend(18, 1) != 1)	
						SDIO_Command((StartAddr*512), 18, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
						//printf("CMD 18 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(status& RX_FIFO_AVAILABLE_DETECT)	// Is Rx data?
						{
							*Rx_buffer++ = rSDIDAT;
							rd_cnt++;
						}
					}

					printf("\nRead Count =%x",rd_cnt);
					break;
	
			case INT:
				pISR_SDI_0=(unsigned)Rd_Int;
				rINTMSK &= ~(BIT_SDI0);	    
			    	rSDIIMSK=5;	// Last & Rx FIFO half int.
				
			    	if(BlockNum<2)	
					{
						SDIO_Command((StartAddr*512), 17, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
						while(Check_CMDend(17, 1) != 1)	
						SDIO_Command((StartAddr*512), 17, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
					}
					else	
					{
						SDIO_Command((StartAddr*512), 18, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
						while(Check_CMDend(18, 1) != 1)	
						SDIO_Command((StartAddr*512), 18, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
					}
				
	    			rSDICSTA = DATA_TIMEOUT|CMD_END|RESP_END;	// Clear cmd_end(with rsp)

	    			while(rd_cnt<128*BlockNum);

	    			rINTMSK |= (BIT_SDI0);
	    			rSDIIMSK=0;	// All mask
	    			break;

			case DMA:
				printf("\nDMA mode data write\n");

				pISR_DMA=(unsigned)DMA_end;
	    			rINTMSK&=~(BIT_DMA);
				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;

				StartStopwatch();

	    			if(BlockNum<2)	
				{
					SDIO_Command((StartAddr*512), 17, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
					while(Check_CMDend(17, 1) != 1)	
					SDIO_Command((StartAddr*512), 17, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
				}
				else	
				{
					SDIO_Command((StartAddr*512), 18, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
					while(Check_CMDend(18, 1) != 1)	
					SDIO_Command((StartAddr*512), 18, SDIO_WAIT_RESP, SDIO_SHORT_RESP, SDIO_WITHOUT_DATA);
				}

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

				rSDIDCON |=BURST4_EN|WORD_TRANSFER|TRANS_AFTER_RESP|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_DMA);
				rINTSUBMSK |= (BIT_SUB_DMA0);
	    			TR_end=0;
	    			rDMASKTRIG0=(1<<2);	//DMA0 stop
				
			default : break;	
		}
		
		if(!Check_DATend()) 
			printf("\nData End Error....\n");


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

		transtime = EndStopwatch();
		CalculationBPS_NORMALSD_MMC(transtime);
/*
		Rx_buffer = (U32 *)SDI_Rx_buffer;
		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;
			}
*/
		BlockNum = 0;
		printf("\n");    
	

}

void SDIO_WriteTest(void)
{
	U32 i, StartAddr,  OneBlockSize, Offset, Testmode;
	//U32 BlockNum=0;
	U32 status;
	U32 transtime;

	wt_cnt=0;
	
	printf("\nSD/MMC block write test\n");

	printf("\n0:Polling write   1:Interrupt write   2:DMA write");
	printf("\nSelect the test mode : ");
    
       Testmode=GetIntNum();
    	
	printf("\nInput Write Start Address : ");
	StartAddr = GetIntNum();

	while((BlockNum == 0) || (BlockNum > 4096))
	{