hs0_mmc.c

samsung 最新芯片2450 的测试程序.

	return 1;
}

int WaitForCommandComplete_CH0(void)
{
	U32 Loop=0;

	while (!(rHM0_NORINTSTS&0x1))
	{
		if (Loop%500000==0&&Loop>0)
		{			
			return 0;
		}
		Loop++;
	}
	return 1;
}

int WaitForTransferComplete_CH0(void)
{
	while (!(rHM0_NORINTSTS&0x2))
	return 1;
}

void InterruptEnable_CH0(U16 NormalIntEn, U16 ErrorIntEn)
{
	ClearErrInterruptStatus_CH0();	
	rHM0_NORINTSTSEN = NormalIntEn;
	rHM0_ERRINTSTSEN = ErrorIntEn;
}

#if BUFFER_BOUNDARY_ch0
void __irq HS_DMA_INT_CH0(void)
{
	U32 i;

    	ClearPending(BIT_SDI0);
	rINTMSK |= (BIT_SDI0);
	BufferBoundary_INT_Cnt_ch0++;
	
	if(rHM0_NORINTSTS & (1<<1))
	{
		HS_DMA_END_ch0=1;
		rINTMSK |= (BIT_SDI0);		
	}
	else if(rHM0_NORINTSTS & (1<<3))
	{
		printf("\nBoundary ISR");
		rHM0_NORINTSTS |= (1<<3);
		i = BufferBoundary_INT_Cnt_ch0 * 0x1000;// 4K Byte boundary
		SetSystemAddressReg_CH0(SDI_Tx_buffer_HSMMC_CH0 + i);
		rINTMSK &= ~(BIT_SDI0);	
	}

}
#else
void __irq HS_DMA_INT_CH0(void)
{
    	ClearPending(BIT_SDI0);
	rINTMSK |= (BIT_SDI0);

	if(rHM0_NORINTSTS & (1<<1))
	{
		HS_DMA_END_ch0=1;	
		rHM0_NORINTSTS |= (1<<1);
	}
}
#endif
void __irq HS_WRITE_INT_CH0(void)
{
	int i;

	printf("\nWrite ISR");
	
    	ClearPending(BIT_SDI0);
	rINTMSK |= (BIT_SDI0);	

	if (!WaitForBufferWriteReady_CH0())
		printf("WriteBuffer NOT Ready\n");
	else
		ClearBufferWriteReadyStatus_CH0();

	for(i=0; i<512/4; i++)
	{
		rHM0_BDATA = *Tx_buffer_HSMMC_ch0++;	
	 	wt_cnt_HSMMC_ch0++;						
	}
	
	WriteBlockCnt_INT_ch0 ++;

	rINTMSK &= ~(BIT_SDI0);
	
	if(BlockNum_HSMMC_ch0 ==  WriteBlockCnt_INT_ch0)
		{
		WRITEINT_DONE_ch0 = 1;
		ClearPending(BIT_SDI0);
		rINTMSK |= (BIT_SDI0);
		}	
}

void __irq HS_READ_INT_CH0(void)
{
	int i;
	
    	ClearPending(BIT_SDI0);
	rINTMSK |= (BIT_SDI0);	

	if (!WaitForBufferReadReady_CH0())
		printf("WriteBuffer NOT Ready\n");
	else
		ClearBufferReadReadyStatus_CH0();

	for(i=0; i<512/4; i++)
	{
		*Rx_buffer_HSMMC_ch0++ = rHM0_BDATA;
		rd_cnt_HSMMC_ch0++;
	}
	
	ReadBlockCnt_INT_ch0 ++;

	rINTMSK &= ~(BIT_SDI0);
	
	if(BlockNum_HSMMC_ch0 ==  ReadBlockCnt_INT_ch0)
		{
		READINT_DONE_ch0 = 1;
		ClearPending(BIT_SDI0);
		rINTMSK |= (BIT_SDI0);
		}	
}

void __irq HS_READ_COMPARE_INT_CH0(void)
{
	int i;

	printf("\nWrite ISR");
	
    	ClearPending(BIT_SDI0);
	rINTMSK |= (BIT_SDI0);	

	if (!WaitForBufferReadReady_CH0())
		printf("WriteBuffer NOT Ready\n");
	else
		ClearBufferReadReadyStatus_CH0();

	for(i=0; i<512/4; i++)
	{
		*Compare_buffer_HSMMC_ch0++ = rHM0_BDATA;
	}
	
	CompareCnt_INT_ch0 ++;
	printf("\nWrite block count = %d", CompareCnt_INT_ch0);	

	rINTMSK &= ~(BIT_SDI0);
	
	if(BlockNum_HSMMC_ch0 ==  CompareCnt_INT_ch0)
		{
		COMPARE_INT_DONE_ch0 = 1;
		ClearPending(BIT_SDI0);
		rINTMSK |= (BIT_SDI0);
		}	
}

void __irq HS_CARD_DETECT_INT_CH0(void)
{
    	ClearPending(BIT_SDI0);
	rINTMSK |= (BIT_SDI0);
	rHM0_NORINTSIGEN &= ~((1<<7)|(1<<6));
	
	printf("Card Detect ISR\n");
	printf("rHM_NORINTSTS = %x\n",rHM0_NORINTSTS);

	if(rHM0_PRNSTS & (1<<16))
		{
		printf("\nCard insert\n");
		HS_CARD_DETECT_ch0 = 1;
		}
	else
		{
		printf("\nCard removal\n");		
		HS_CARD_DETECT_ch0 = 1;
		}
	
	rHM0_NORINTSTS |= (1<<7)|(1<<6);
	rINTMSK &= ~(BIT_SDI0);
}

void DisplayCardInformation_CH0(void)
{
	U32 C_SIZE, C_SIZE_MULT, READ_BL_LEN, READ_BL_PARTIAL, CardSize, OneBlockSize;
	
	if(ThisIsMmc_ch0)
	{
		m_ucMMCSpecVer_ch0=(rHM0_RSPREG3>>18)& 0xF;
		printf("=>  m_ucMMCSpecVer_ch0=%d\n", m_ucMMCSpecVer_ch0);
	}

	READ_BL_LEN = ((rHM0_RSPREG2>>8) & 0xf) ;
	READ_BL_PARTIAL = ((rHM0_RSPREG2>>7) & 0x1) ;
	C_SIZE = ((rHM0_RSPREG2 & 0x3) << 10) | ((rHM0_RSPREG1 >> 22) & 0x3ff);
	C_SIZE_MULT = ((rHM0_RSPREG1>>7)&0x7);
	
	CardSize = (1<<READ_BL_LEN)*(C_SIZE+1)*(1<<(C_SIZE_MULT+2))/1048576;
	OneBlockSize = (1<<READ_BL_LEN);

	printf("\n READ_BL_LEN: %d",READ_BL_LEN);	
	printf("\n READ_BL_PARTIAL: %d",READ_BL_PARTIAL);	
	printf("\n C_SIZE: %d",C_SIZE);	
	printf("\n C_SIZE_MULT: %d\n",C_SIZE_MULT);	

	printf("\n One Block Size: %dByte",OneBlockSize);	
	printf("\n Total Card Size: %dMByte\n\n\n",CardSize+1);	
}

void CalculationBPS_HSMMC_CH0(int Time)
{
	float x=0;
	int y=0;
	float bps=0;

	x = (float)((float)1000000/(float)Time); //Unit is usec

	y = BlockNum_HSMMC_ch0 * 512 * 8;
	
	bps = x*(float)y;
	
	printf("\n\n\nTransfer Time = %dusec",Time);
	printf("\nTransferSize = %dKByte",y/(8*1024));
	printf("\nBPS = %fMByte/sec\n\n",bps/(1000000*8));
}

void DataRead_ForCompare_CH0(int StartAddr)
{
	U32 i=0,j=0;
	COMPARE_INT_DONE_ch0 = 0;

	ClearPending(BIT_SDI0);
	rHM0_NORINTSIGEN &= ~(0xffff);
	
	Compare_buffer_HSMMC_ch0 = (U32 *)SDI_Compare_buffer_HSMMC_CH0;
    	for(i=0 ; i<(512 * BlockNum_HSMMC_ch0)/4 ; i++)	
		*(Compare_buffer_HSMMC_ch0+i) = 0x0;   
		
	printf("\nPolling mode data read\n");
	printf("\nRead BlockNum = %d\n",BlockNum_HSMMC_ch0);

	if(SectorMode_ch0 == 1)
		StartAddr = StartAddr;
	else
		StartAddr = StartAddr * 512;

	while (!IsCardInProgrammingState_CH0());

	SetBlockSizeReg_CH0(7, 512); // Maximum DMA Buffer Size, Block Size
	SetBlockCountReg_CH0(BlockNum_HSMMC_ch0); // Block Numbers to Write
	SetArgumentReg_CH0(StartAddr); // Card Address to Write

	if(BlockNum_HSMMC_ch0 == 1)//single block
		{
			printf("Single block read\n");
			SetTransferModeReg_CH0(0, 1, 1, 1, 0);
			SetCommandReg_CH0(17, 0); // CMD17: Single-Read						
		}
	else//multi block
		{
			printf("Multi block read\n");
			SetTransferModeReg_CH0(1, 1, 1, 1, 0);
			SetCommandReg_CH0(18, 0); // CMD18: Multi-Read
		}
	
	if (!WaitForCommandComplete_CH0())
	{
		printf("\nCommand is NOT completed\n");
	}
	ClearCommandCompleteStatus_CH0();	
	
	for(j=0; j<BlockNum_HSMMC_ch0; j++)
		{
			if (!WaitForBufferReadReady_CH0());
				//printf("ReadBuffer NOT Ready\n");
			else
				ClearBufferReadReadyStatus_CH0();
			for(i=0; i<512/4; i++)
			{
				*Compare_buffer_HSMMC_ch0++ = rHM0_BDATA;
				CompareCnt_INT_ch0++;
			}
		}

	printf("\nRead count=%x\n",CompareCnt_INT_ch0);
	if(!WaitForTransferComplete_CH0())
		{
		printf(("Transfer NOT Complete\n"));
		}
	ClearTransferCompleteStatus_CH0();

	printf("\n\nrHM_NORINTSTS = %x",rHM0_NORINTSTS);
}

void DataCompare_HSMMC_CH0(U32 a0, U32 a1, U32 bytes)
{	
	U32 * pD0 = (U32 *)a0;
	U32 * pD1 = (U32 *)a1;
	U32  ErrCnt = 0;
	U32 i;

	for (i=0; i<bytes; i++)
	{
		if (*pD0 != *pD1) 
		{
			printf("\n%08x=%02x <-> %08x=%02x", pD0, *pD0, pD1, *pD1);
			ErrCnt++;
		}
		pD0++;
		pD1++;
	}
	printf("\nTotal Error cnt = %d",ErrCnt);

	if(ErrCnt == 0)
		printf("\nData Compare Ok\n");
}

void GenerateDescriptor_CH0( ADMA_DESC_CH0* Desc, U32 DataAddr, U32 DataSz, U32 IsEnd, U32 IsInt )
{
	Desc->uDataAddr = DataAddr;
	Desc->uDataSz   = DataSz;
	Desc->uRsvd     = 0;
	Desc->uAct      = ADMA_TRAN_CH0;
	Desc->uNull     = 0;
	Desc->uInt      = IsInt;
	Desc->uEnd      = IsEnd;
	Desc->uValid    = 1;
}

void GenerateLinkerDescriptor_CH0( ADMA_DESC_CH0* Desc, ADMA_DESC_CH0* NextDescAddr )
{
	Desc->uDataAddr = (U32)NextDescAddr;
	Desc->uDataSz   = 0;
	Desc->uRsvd     = 0;
	Desc->uAct      = ADMA_LINK_CH0;
	Desc->uNull     = 0;
	Desc->uInt      = 0;
	Desc->uEnd      = 0;
	Desc->uValid    = 1;
}

void SetADMASystemAddressReg_CH0(U32* SysAddr)
{
	rHM0_HOSTCTL = rHM0_HOSTCTL & ~(0x3<<3) | (0x2<<3);
	rHM0_ADMSYSADDR = (U32)SysAddr;
}

void __irq HS_ADMA_INT_CH0(void)
{
    	ClearPending(BIT_SDI0);
	rINTMSK |= (BIT_SDI0);
	//printf("\nrHM0_NORINTSTS = %x",rHM0_NORINTSTS);
	
	if(rHM0_ADMAERR & (1<<8))
		{
		//printf("\nDescriptor line is complete\n");
		rHM0_NORINTSTS = (1<<3)|(1<<2);
		HS_DESCRIPTOR_INT_ch0++;
		rHM0_ADMAERR = (1<<9)|(1<<8);
		rINTMSK &= ~(BIT_SDI0);
		}
	else if(rHM0_NORINTSTS & (1<<1))
		{
		//printf("\nADMA transfer is complete\n");
		HS_ADMA_END_ch0++;	
		rHM0_NORINTSTS = (1<<1);
		//rINTMSK |= (BIT_SDI0);
		}
}


void DataRead_ForCompare_ADMA_CH0(int StartAddr)
{
	U32 i=0,j=0;
	COMPARE_INT_DONE_ch0 = 0;

	ClearPending(BIT_SDI0);
	rHM0_NORINTSIGEN &= ~(0xffff);
	
	Compare_buffer_HSMMC_ch0 = (U32 *)SDI_Compare_buffer_HSMMC_CH0;
    	for(i=0 ; i<(512 * BlockNum_HSMMC_ch0)/4 ; i++)	
		*(Compare_buffer_HSMMC_ch0+i) = 0x0;   
		
	printf("\nPolling mode data read\n");
	printf("\nRead BlockNum = %d\n",BlockNum_HSMMC_ch0);

	if(SectorMode_ch0 == 1)
		StartAddr = StartAddr;
	else
		StartAddr = StartAddr * 512;

	while (!IsCardInProgrammingState_CH0());

	SetBlockSizeReg_CH0(7, 512); // Maximum DMA Buffer Size, Block Size
	SetBlockCountReg_CH0(BlockNum_HSMMC_ch0*4); // Block Numbers to Write
	SetArgumentReg_CH0(StartAddr); // Card Address to Write

	if(BlockNum_HSMMC_ch0 == 1)//single block
		{
			printf("Single block read\n");
			SetTransferModeReg_CH0(0, 1, 1, 1, 0);
			SetCommandReg_CH0(17, 0); // CMD17: Single-Read						
		}
	else//multi block
		{
			printf("Multi block read\n");
			SetTransferModeReg_CH0(1, 1, 1, 1, 0);
			SetCommandReg_CH0(18, 0); // CMD18: Multi-Read
		}
	
	if (!WaitForCommandComplete_CH0())
	{
		printf("\nCommand is NOT completed\n");
	}
	ClearCommandCompleteStatus_CH0();	
	
	for(j=0; j<BlockNum_HSMMC_ch0*4; j++)
		{
			if (!WaitForBufferReadReady_CH0());
				//printf("ReadBuffer NOT Ready\n");
			else
				ClearBufferReadReadyStatus_CH0();
			for(i=0; i<512/4; i++)
			{
				*Compare_buffer_HSMMC_ch0++ = rHM0_BDATA;
				CompareCnt_INT_ch0++;
			}
		}

	printf("\nRead count=%x\n",CompareCnt_INT_ch0);
	if(!WaitForTransferComplete_CH0())
		{
		printf(("Transfer NOT Complete\n"));
		}
	ClearTransferCompleteStatus_CH0();

	printf("\n\nrHM_NORINTSTS = %x",rHM0_NORINTSTS);
}

void HS_MMC_ADMATest_CH0(void)
{

	U32 uSrcAddr;
	U32 uDataSize;
	U32 uNumOfBlocks;
	U32 uSrcAddr1;
	U32 uDstAddr;
	U32 uDstAddr1;
	U32 StartAddr;
	U32 i,j;

	U32 uTxBufAddr = SDI_Tx_buffer_HSMMC_CH0;
	U32 uCompareBufAddr = SDI_Compare_buffer_HSMMC_CH0;

	ADMA_DESC_CH0 WrDscrpt[2];
	ADMA_DESC_CH0 WrLinkDscrpt;
	ADMA_DESC_CH0 RdDscrpt[2];

	printf("\nInput Write Start block number : ");
	StartAddr = GetIntNum();
	
	printf("Input number of Block [1~65535] : ");
	BlockNum_HSMMC_ch0 = GetIntNum();

	uDataSize = BlockNum_HSMMC_ch0*512;

	uSrcAddr = SDI_Tx_buffer_HSMMC_CH0;
	uSrcAddr1 = uSrcAddr + uDataSize + 0x2000; // 8KB
	uDstAddr = uSrcAddr1 + uDataSize + 0x2000;
	uDstAddr1 = uDstAddr + uDataSize + 0x2000;

	printf("\nSrcAddr = 0x%x",uSrcAddr);
	printf("\nSrcAddr1 = 0x%x",uSrcAddr1);
	printf("\nDstAddr = 0x%x",uDstAddr);
	printf("\nDstAddr1 = 0x%x",uDstAddr1);
	
	if(SectorMode_ch0 == 1)
	{
	StartAddr = StartAddr;
	printf("\nSector Mode Addressing");
	}
	else
	{
	StartAddr = StartAddr * 512;
	printf("\nByte Mode Addressing");
	}

	// 1. Make a descriptor table

	GenerateDescriptor_CH0(&WrDscrpt[0], uSrcAddr, uDataSize, ADMA_CONTINUE_CH0, ADMA_INTEn_CH0);
	GenerateLinkerDescriptor_CH0(&WrLinkDscrpt, &WrDscrpt[1]);
	GenerateDescriptor_CH0(&WrDscrpt[1], uSrcAddr1, uDataSize, ADMA_END_CH0, ADMA_INTEn_CH0);
	
	GenerateDescriptor_CH0(&RdDscrpt[0], uDstAddr, uDataSize, ADMA_CONTINUE_CH0, ADMA_INTEn_CH0);
	GenerateDescriptor_CH0(&RdDscrpt[1], uDstAddr1, uDataSize, ADMA_END_CH0, ADMA_INTEn_CH0);

	// 2. Make source data and initialize destination
	
	for ( i=0; i<BlockNum_HSMMC_ch0*128; i++ )
	{
		((U32 *)uSrcAddr)[i] = rand(); // rand();
		((U32 *)uSrcAddr1)[i] = rand(); // rand();
		((U32 *)uDstAddr)[i] = 0;
		((U32 *)uDstAddr1)[i] = 0;
	}

	// 5. Writing ADMA mode

	pISR_SDI_0 = (unsigned)HS_ADMA_INT_CH0;
	
	rINTMSK &= ~(BIT_SDI0);				
	rHM0_NORINTSTSEN = (rHM0_NORINTSTSEN & ~(0xffff)) |
						BUFFER_READREADY_STS_INT_EN_CH0 | 
						DMA_STS_INT_EN_CH0 |
						TRANSFERCOMPLETE_STS_INT_EN_CH0 |
						COMMANDCOMPLETE_STS_INT_EN_CH0;
	rHM0_NORINTSIGEN = (rHM0_NORINTSIGEN & ~(0xffff)) | DMA_SIG_INT_EN_CH0 | TRANSFERCOMPLETE_SIG_INT_EN_CH0;
	
	SetADMASystemAddressReg_CH0((U32*)&WrDscrpt[0]);
	
	SetBlockSizeReg_CH0(7, 512); // Maximum DMA Buffer Size, Block Size				
	SetBlockCountReg_CH0(BlockNum_HSMMC_ch0); // Block Numbers to Write	
	SetArgumentReg_CH0(StartAddr);// Card Start Block Address to Write				
	
	if (uNumOfBlocks == 1)
	{
		SetTransferModeReg_CH0(0, 0, 1, 1, 1);
		SetCommandReg_CH0(24, 0); // CMD24: Single-Write