hs1_mmc.c

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

}

int WaitForBufferWriteReady_CH1(void)
{
	while (!(rHM1_NORINTSTS&0x10));
	return 1;
}

int WaitForBufferReadReady_CH1(void)
{
	U32 uLoop=0;

	while (!(rHM1_NORINTSTS&0x20))
	{
		if (uLoop%500000==0&&uLoop>0)
		{			
			return 0;
		}
		uLoop++;
	}
	return 1;
}

int WaitForCommandComplete_CH1(void)
{
	U32 Loop=0;

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

int WaitForTransferComplete_CH1(void)
{
	while (!(rHM1_NORINTSTS&0x2))
	return 1;
}

void InterruptEnable_CH1(U16 NormalIntEn, U16 ErrorIntEn)
{
	ClearErrInterruptStatus_CH1();	
	rHM1_NORINTSTSEN = NormalIntEn;
	rHM1_ERRINTSTSEN = ErrorIntEn;
}

#if BUFFER_BOUNDARY_ch1
void __irq HS_DMA_INT_CH1(void)
{
	U32 i;

    	ClearPending(BIT_SDI1);
	rINTMSK |= (BIT_SDI1);
	BufferBoundary_INT_Cnt_ch1++;
	
	if(rHM1_NORINTSTS & (1<<1))
	{
		HS_DMA_END_ch1=1;
		rINTMSK |= (BIT_SDI1);		
	}
	else if(rHM1_NORINTSTS & (1<<3))
	{
		printf("\nBoundary ISR");
		rHM1_NORINTSTS = (1<<3);
		i = BufferBoundary_INT_Cnt_ch1 * 0x1000;// 4K Byte boundary
		SetSystemAddressReg_CH1(SDI_Tx_buffer_HSMMC_CH1 + i);
		rINTMSK &= ~(BIT_SDI1);	
	}

}
#else
void __irq HS_DMA_INT_CH1(void)
{
    	ClearPending(BIT_SDI1);
	rINTMSK |= (BIT_SDI1);
	CEATA_ISR_ch1++;
	printf("\nISR rHM1_NORINTSTS = %x",rHM1_NORINTSTS);
	if(rHM1_NORINTSTS & (1<<1))
	{
		//printf("\nTransfer Complete\n");
		HS_DMA_END_ch1=1;	
		rHM1_NORINTSTS = (1<<1);
		//printf("\nData transfer interrupt !!!!!!!!!!!!!!!!!!!!!!!!!");
	}
	
	if(rHM1_NORINTSTS & (1<<9))
	{
		//printf("\nCCS interrupt !!!!!!!!!!!!!!!!!!!!!!!!!");
		CCS_END_ch1= 1;
		rHM1_NORINTSTS = (1<<9);
	}

	rINTMSK &= ~(BIT_SDI1);

	if(CEATA_ISR_ch1== 2)
	{
	ClearPending(BIT_SDI1);
	rINTMSK |= (BIT_SDI1);
	}
}
#endif
void __irq HS_WRITE_INT_CH1(void)
{
	int i;

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

	if (!WaitForBufferWriteReady_CH1())
		printf("WriteBuffer NOT Ready\n");
	else
		ClearBufferWriteReadyStatus_CH1();

	for(i=0; i<512/4; i++)
	{
		rHM1_BDATA = *Tx_buffer_HSMMC_ch1++;	
	 	wt_cnt_HSMMC_ch1++;						
	}
	
	WriteBlockCnt_INT_ch1 ++;

	rINTMSK &= ~(BIT_SDI1);
	
	if(BlockNum_HSMMC_ch1 ==  WriteBlockCnt_INT_ch1)
		{
		WRITEINT_DONE_ch1 = 1;
		ClearPending(BIT_SDI1);
		rINTMSK |= (BIT_SDI1);
		}	
}

void __irq HS_READ_INT_CH1(void)
{
	int i;
	
    	ClearPending(BIT_SDI1);
	rINTMSK |= (BIT_SDI1);	

	if (!WaitForBufferReadReady_CH1())
		printf("WriteBuffer NOT Ready\n");
	else
		ClearBufferReadReadyStatus_CH1();

	for(i=0; i<512/4; i++)
	{
		*Rx_buffer_HSMMC_ch1++ = rHM1_BDATA;
		rd_cnt_HSMMC_ch1++;
	}
	
	ReadBlockCnt_INT_ch1 ++;

	rINTMSK &= ~(BIT_SDI1);
	
	if(BlockNum_HSMMC_ch1 ==  ReadBlockCnt_INT_ch1)
		{
		READINT_DONE_ch1 = 1;
		ClearPending(BIT_SDI1);
		rINTMSK |= (BIT_SDI1);
		}	
}

void __irq HS_READ_COMPARE_INT(void)
{
	int i;

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

	if (!WaitForBufferReadReady_CH1())
		printf("WriteBuffer NOT Ready\n");
	else
		ClearBufferReadReadyStatus_CH1();

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

	rINTMSK &= ~(BIT_SDI1);
	
	if(BlockNum_HSMMC_ch1 ==  CompareCnt_INT_ch1)
		{
		COMPARE_INT_DONE_ch1 = 1;
		ClearPending(BIT_SDI1);
		rINTMSK |= (BIT_SDI1);
		}	
}

void __irq HS_CARD_DETECT_INT_CH1(void)
{
    	ClearPending(BIT_SDI1);
	rINTMSK |= (BIT_SDI1);
	rHM1_NORINTSIGEN &= ~((1<<7)|(1<<6));
	
	printf("Card Detect ISR\n");
	printf("rHM_NORINTSTS = %x\n",rHM1_NORINTSTS);

	if(rHM1_PRNSTS & (1<<16))
		{
		printf("\nCard insert\n");
		HS_CARD_DETECT_ch1 = 1;
		}
	else
		{
		printf("\nCard removal\n");		
		HS_CARD_DETECT_ch1 = 1;
		}
	
	rHM1_NORINTSTS |= (1<<7)|(1<<6);
	rINTMSK &= ~(BIT_SDI1);
}

void DisplayCardInformation_CH1(void)
{
	U32 C_SIZE, C_SIZE_MULT, READ_BL_LEN, READ_BL_PARTIAL, CardSize, OneBlockSize;
	U32 i,j,k;
	
	if(ThisIsMmc_ch1)
	{
		m_ucMMCSpecVer_ch1=(rHM1_RSPREG3>>18)& 0xF;
		printf("=>  m_ucMMCSpecVer_ch1=%d\n", m_ucMMCSpecVer_ch1);
	}

	READ_BL_LEN = ((rHM1_RSPREG2>>8) & 0xf) ;
	READ_BL_PARTIAL = ((rHM1_RSPREG2>>7) & 0x1) ;
	C_SIZE = ((rHM1_RSPREG2 & 0x3) << 10) | ((rHM1_RSPREG1 >> 22) & 0x3ff);
	C_SIZE_MULT = ((rHM1_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);	

	i = (unsigned int)((rHM1_RSPREG2>>8) & 0xf);										// Max Read data block length
	j = (unsigned int)(((rHM1_RSPREG2 & 0x3) << 10) | ((rHM1_RSPREG1 >> 22) & 0x3ff));	// Device Size
	k = (unsigned int)((rHM1_RSPREG1>>7)&0x7);										// Device Size Multiflier
	// 1<<i   ->  1<<(i-9)
	TotalCardBlock_number_ch1 = (1<<(i-9))*(j+1)*(1<<(k+2));
}

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

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

	y = BlockNum_HSMMC_ch1 * 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_ADMA_CH1(int StartAddr)
{
	U32 i=0,j=0;
	COMPARE_INT_DONE_ch1 = 0;

	ClearPending(BIT_SDI1);
	rHM1_NORINTSIGEN &= ~(0xffff);
	
	Compare_buffer_HSMMC_ch1 = (U32 *)SDI_Compare_buffer_HSMMC_CH1;
    	for(i=0 ; i<(512 * BlockNum_HSMMC_ch1)/4 ; i++)	
		*(Compare_buffer_HSMMC_ch1+i) = 0x0;   
		
	printf("\nPolling mode data read\n");
	printf("\nRead BlockNum = %d\n",BlockNum_HSMMC_ch1);

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

	while (!IsCardInProgrammingState_CH1());

	SetBlockSizeReg_CH1(7, 512); // Maximum DMA Buffer Size, Block Size
	SetBlockCountReg_CH1(BlockNum_HSMMC_ch1*4); // Block Numbers to Write
	SetArgumentReg_CH1(StartAddr); // Card Address to Write

	if(BlockNum_HSMMC_ch1 == 1)//single block
		{
			printf("Single block read\n");
			SetTransferModeReg_CH1(0, 1, 1, 1, 0);
			SetCommandReg_CH1(17, 0); // CMD17: Single-Read						
		}
	else//multi block
		{
			printf("Multi block read\n");
			SetTransferModeReg_CH1(1, 1, 1, 1, 0);
			SetCommandReg_CH1(18, 0); // CMD18: Multi-Read
		}
	
	if (!WaitForCommandComplete_CH1())
	{
		printf("\nCommand is NOT completed\n");
	}
	ClearCommandCompleteStatus_CH1();	
	
	for(j=0; j<BlockNum_HSMMC_ch1*4; j++)
		{
			if (!WaitForBufferReadReady_CH1());
				//printf("ReadBuffer NOT Ready\n");
			else
				ClearBufferReadReadyStatus_CH1();
			for(i=0; i<512/4; i++)
			{
				*Compare_buffer_HSMMC_ch1++ = rHM1_BDATA;
				CompareCnt_INT_ch1++;
			}
		}

	printf("\nRead count=%x\n",CompareCnt_INT_ch1);
	if(!WaitForTransferComplete_CH1())
		{
		printf(("Transfer NOT Complete\n"));
		}
	ClearTransferCompleteStatus_CH1();

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


void DataRead_ForCompare_CH1(int StartAddr)
{
	U32 i=0,j=0;
	COMPARE_INT_DONE_ch1 = 0;

	ClearPending(BIT_SDI1);
	rHM1_NORINTSIGEN &= ~(0xffff);
	
	Compare_buffer_HSMMC_ch1 = (U32 *)SDI_Compare_buffer_HSMMC_CH1;
    	for(i=0 ; i<(512 * BlockNum_HSMMC_ch1)/4 ; i++)	
		*(Compare_buffer_HSMMC_ch1+i) = 0x0;   
		
	printf("\nPolling mode data read\n");
	printf("\nRead BlockNum = %d\n",BlockNum_HSMMC_ch1);

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

	while (!IsCardInProgrammingState_CH1());

	SetBlockSizeReg_CH1(7, 512); // Maximum DMA Buffer Size, Block Size
	SetBlockCountReg_CH1(BlockNum_HSMMC_ch1); // Block Numbers to Write
	SetArgumentReg_CH1(StartAddr); // Card Address to Write

	if(BlockNum_HSMMC_ch1 == 1)//single block
		{
			printf("Single block read\n");
			SetTransferModeReg_CH1(0, 1, 1, 1, 0);
			SetCommandReg_CH1(17, 0); // CMD17: Single-Read						
		}
	else//multi block
		{
			printf("Multi block read\n");
			SetTransferModeReg_CH1(1, 1, 1, 1, 0);
			SetCommandReg_CH1(18, 0); // CMD18: Multi-Read
		}
	
	if (!WaitForCommandComplete_CH1())
	{
		printf("\nCommand is NOT completed\n");
	}
	ClearCommandCompleteStatus_CH1();	
	
	for(j=0; j<BlockNum_HSMMC_ch1; j++)
		{
			if (!WaitForBufferReadReady_CH1());
				//printf("ReadBuffer NOT Ready\n");
			else
				ClearBufferReadReadyStatus_CH1();
			for(i=0; i<512/4; i++)
			{
				*Compare_buffer_HSMMC_ch1++ = rHM1_BDATA;
				CompareCnt_INT_ch1++;
			}
		}

	printf("\nRead count=%x\n",CompareCnt_INT_ch1);
	if(!WaitForTransferComplete_CH1())
		{
		printf(("Transfer NOT Complete\n"));
		}
	ClearTransferCompleteStatus_CH1();

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

void DataCompare_HSMMC_CH1(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_CH1( ADMA_DESC_CH1* Desc, U32 DataAddr, U32 DataSz, U32 IsEnd, U32 IsInt )
{
	Desc->uDataAddr = DataAddr;
	Desc->uDataSz   = DataSz;
	Desc->uRsvd     = 0;
	Desc->uAct      = ADMA_TRAN_CH1;
	Desc->uNull     = 0;
	Desc->uInt      = IsInt;
	Desc->uEnd      = IsEnd;
	Desc->uValid    = 1;
}

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

void SetADMASystemAddressReg_CH1(U32* SysAddr)
{
	rHM1_HOSTCTL = rHM1_HOSTCTL & ~(0x3<<3) | (0x2<<3);
	rHM1_ADMSYSADDR = (U32)SysAddr;
}

void __irq HS_ADMA_INT_CH1(void)
{
    	ClearPending(BIT_SDI1);
	rINTMSK |= (BIT_SDI1);
	//printf("\nrHM1_NORINTSTS = %x",rHM1_NORINTSTS);
	
	if(rHM1_ADMAERR & (1<<8))
		{
		//printf("\nDescriptor line is complete\n");
		rHM1_NORINTSTS = (1<<3)|(1<<2);
		HS_DESCRIPTOR_INT_ch1++;
		rHM1_ADMAERR = (1<<9)|(1<<8);
		rINTMSK &= ~(BIT_SDI1);
		}
	else if(rHM1_NORINTSTS & (1<<1))
		{
		//printf("\nADMA transfer is complete\n");
		HS_ADMA_END_ch1++;	
		rHM1_NORINTSTS = (1<<1);
		//rINTMSK |= (BIT_SDI1);
		}
}

void HS_MMC_ADMATest_CH1(void)
{

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

	U32 uTxBufAddr = SDI_Tx_buffer_HSMMC_CH1;
	U32 uCompareBufAddr = SDI_Compare_buffer_HSMMC_CH1;

	ADMA_DESC_CH1 WrDscrpt[2];
	ADMA_DESC_CH1 WrLinkDscrpt;
	ADMA_DESC_CH1 RdDscrpt[2];

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

	uDataSize = BlockNum_HSMMC_ch1*512;

	uSrcAddr = SDI_Tx_buffer_HSMMC_CH1;
	uSrcAddr1 = uSrcAddr + uDataSize; // 8KB
	uDstAddr = uSrcAddr1 + uDataSize;
	uDstAddr1 = uDstAddr + uDataSize;

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