ata_test.c

三星 s3c6400测试代码

	ATA_WriteBlocks(g_ucATAConNum, uDeviceLBA, uSector, (u32)(g_oaATAInform[g_ucATAConNum].puATAWriteBuf));
	ATA_ReadBlocks(g_ucATAConNum, uDeviceLBA, uSector, (u32)(g_oaATAInform[g_ucATAConNum].puATAReadBuf));

	if (Compare((u32)(g_oaATAInform[g_ucATAConNum].puATAWriteBuf), (u32)(g_oaATAInform[g_ucATAConNum].puATAReadBuf), uSector*128) == FALSE)
	{
		Disp("Error detected\n");
		Dump32((u32)(g_oaATAInform[g_ucATAConNum].puATAReadBuf), uSector*128);
	}
	else
	{
		Disp("Write/Read operation in UDMA mode is OK\n");
	}
	ATA_CloseMedia(g_ucATAConNum);
}

//////////
// Function Name : ATA_TestUdmaModeRead
// Function Description : 
//   This function tests  function of ATA.
// Input : NONE
// Output : NONE
// Version : v0.1 
void	ATA_TestUdmaModeRead(void)
{
	u32		uDeviceLBA	= 0;
	u32		uSector		= 0;
	u32		uLoopCnt 	= 0;

	ATA_OpenMedia(g_ucATAConNum, eATA_MODE_UDMA);

	Disp("\nInput device sector address[max: 0x%x]\n",g_oaATAInform[g_ucATAConNum].uMaxSectors);
	uDeviceLBA = (u32)GetIntNum();

	Disp("Input sector count[max: 0x%x]\n",g_oaATAInform[g_ucATAConNum].uMaxSectors - uDeviceLBA);
	uSector = (u32)GetIntNum();

	for (uLoopCnt=0; uLoopCnt < uSector*512; uLoopCnt++)
	{
		CF_SetMem(eBYTE, (u32)((u8*)g_oaATAInform[g_ucATAConNum].puATAReadBuf + uLoopCnt), 0);
	}

	Disp("Press Enter \n");	
	getchar();

	ATA_ReadBlocks(g_ucATAConNum, uDeviceLBA, uSector, (u32)(g_oaATAInform[g_ucATAConNum].puATAReadBuf));

	Dump32((u32)(g_oaATAInform[g_ucATAConNum].puATAReadBuf), uSector*128);

	ATA_CloseMedia(g_ucATAConNum);
}

void __irq Isr_AtaDma(void) 
{
	u32 uNthBit;
	bool bStatus;

	if (!ATA_FindInterruptRequest(g_ucATAConNum,&uNthBit)) {
		INTC_ClearVectAddr();
	}

	Disp("ISR Ata : %d\n", uNthBit);

#if 0	// These lines are just for ATA Bug Test
	ATA_SetTransferCommand(g_ucATAConNum, eATA_XFR_CMD_STOP);
	ATA_SetTransferCommand(g_ucATAConNum, eATA_XFR_CMD_CONTINUE);
#endif	

	ATA_ClearPending(g_ucATAConNum, uNthBit);

	if (uNthBit == 0 || uNthBit == 1)
	{
		ATA_IsDmaDone(g_ucATAConNum);
		g_oaATAInform[g_ucATAConNum].bIsXferDone = TRUE;
	}
	else if (uNthBit == 2)
	{
		g_oaATAInform[g_ucATAConNum].bIsDone = TRUE;
	}


	INTC_ClearVectAddr();

	if (uNthBit == 3)
	{
		bStatus = ATA_IsTBufFullContinue(g_ucATAConNum);
		if (bStatus) 
			ATA_SetTransferCommand(g_ucATAConNum, eATA_XFR_CMD_CONTINUE);
	}
	else if (uNthBit == 4)
	{
		bStatus = ATA_IsSBufEmptyContinue(g_ucATAConNum);
		if (bStatus) 
			ATA_SetTransferCommand(g_ucATAConNum, eATA_XFR_CMD_CONTINUE);
	}

}
//////////
// Function Name : ATA_TestPioDmaMode_Int
// Function Description : 
//   This function tests  function of ATA.
// Input : NONE
// Output : NONE
// Version : v0.1 
void ATA_TestPioDmaMode_Int(void)
{
	u32		uDeviceLBA	= 0;
	u32		uSector		= 0;
	u32		uLoopCnt 	= 0;

	ATA_OpenMedia(g_ucATAConNum, eATA_MODE_PIODMA);

	Disp("\nInput device sector address[max: 0x%x]\n",g_oaATAInform[g_ucATAConNum].uMaxSectors);
	uDeviceLBA = (u32)GetIntNum();

	Disp("Input sector count[max: 0x%x]\n",g_oaATAInform[g_ucATAConNum].uMaxSectors - uDeviceLBA);
	uSector = (u32)GetIntNum();

	for (uLoopCnt=0; uLoopCnt < uSector*512; uLoopCnt++)
	{
		CF_SetMem(eBYTE, (u32)((u8*)g_oaATAInform[g_ucATAConNum].puATAReadBuf + uLoopCnt), 0);
		CF_SetMem(eBYTE, (u32)((u8*)g_oaATAInform[g_ucATAConNum].puATAWriteBuf + uLoopCnt), (uLoopCnt+4)%256);
	}

	Disp("Press Enter \n");	
	getchar();

	g_oaATAInform[g_ucATAConNum].bIsXferDone = FALSE;

	ATA_ClearAllInterrupt(g_ucATAConNum);

	INTC_SetVectAddr( NUM_CFC, Isr_AtaDma);
	INTC_Enable( NUM_CFC);
	
	for (uLoopCnt=0; uLoopCnt<uSector; uLoopCnt++)
	{
//		Disp("(W)uDeviceLBA:%d, uLoopCnt:%d, uSector:%d\n", uDeviceLBA, uLoopCnt, uSector);
		ATA_StartWritingSectors(g_ucATAConNum, uDeviceLBA+uLoopCnt, 1, (u32)(g_oaATAInform[g_ucATAConNum].puATAWriteBuf+uLoopCnt*512));

		while(g_oaATAInform[g_ucATAConNum].bIsXferDone != TRUE) ;
		g_oaATAInform[g_ucATAConNum].bIsXferDone = FALSE;	
	}

	for (uLoopCnt=0; uLoopCnt<uSector; uLoopCnt++)
	{
//		Disp("(R)uDeviceLBA:%d, uLoopCnt:%d, uSector:%d\n", uDeviceLBA, uLoopCnt, uSector);
		ATA_StartReadingSectors(g_ucATAConNum, uDeviceLBA+uLoopCnt, 1, (u32)(g_oaATAInform[g_ucATAConNum].puATAReadBuf+uLoopCnt*512));

		while(g_oaATAInform[g_ucATAConNum].bIsXferDone != TRUE) ;
		g_oaATAInform[g_ucATAConNum].bIsXferDone = FALSE;	
	}

	if (Compare((u32)(g_oaATAInform[g_ucATAConNum].puATAWriteBuf), (u32)(g_oaATAInform[g_ucATAConNum].puATAReadBuf), uSector*128) == FALSE)
	{
		Disp("Error detected\n");
		Dump32((u32)(g_oaATAInform[g_ucATAConNum].puATAReadBuf), uSector*128);
	}
	else
	{
		Disp("Write/Read operation is OK\n");
	}

	INTC_Disable( NUM_CFC);
	
	ATA_CloseMedia(g_ucATAConNum);
}

//////////
// Function Name : ATA_TestUDmaMode_Int
// Function Description : 
//   This function tests  function of ATA.
// Input : NONE
// Output : NONE
// Version : v0.1 
void	ATA_TestUDmaMode_Int(void)
{
	u32		uDeviceLBA	= 0;
	u32		uSector		= 0;
	u32		uLoopCnt 	= 0;

	u32		uCurrentCount;
	u32		uRemainderCount;
	u32		uCurrentLba;
	u32		uCurrentAddr;
	u32		uRound;
	u8		ucCon = g_ucATAConNum;
	
	ATA_OpenMedia(ucCon, eATA_MODE_UDMA);

	Disp("\nInput device sector address[max: 0x%x]\n",g_oaATAInform[ucCon].uMaxSectors);
	uDeviceLBA = (u32)GetIntNum();

	Disp("Input sector count[max: 0x%x]\n",g_oaATAInform[ucCon].uMaxSectors - uDeviceLBA);
	uSector = (u32)GetIntNum();

	for (uLoopCnt=0; uLoopCnt < uSector*512; uLoopCnt++)
	{
		CF_SetMem(eBYTE, (u32)((u8*)g_oaATAInform[ucCon].puATAReadBuf + uLoopCnt), 0);
		CF_SetMem(eBYTE, (u32)((u8*)g_oaATAInform[ucCon].puATAWriteBuf + uLoopCnt), (uLoopCnt+5)%256);
	}

	Disp("Press Enter \n");	
	getchar();

	g_oaATAInform[ucCon].bIsXferDone = FALSE;

	ATA_ClearAllInterrupt(ucCon);

	INTC_SetVectAddr( NUM_CFC, Isr_AtaDma);
	INTC_Enable( NUM_CFC);

	// Max transfer block count per command is 256.
	uRemainderCount = uSector;
	uRound = 0;	
	
	while(uRemainderCount != 0) {
		if(uRemainderCount>256) {
			uCurrentCount = 256; //0 means 256
			uRemainderCount -= 256;
		} else {
			uCurrentCount = uRemainderCount;
			uRemainderCount = 0;
		}
		uCurrentLba = uDeviceLBA + uRound*256;
		uCurrentAddr = (u32)(g_oaATAInform[ucCon].puATAWriteBuf + uRound*256*512);

		ATA_StartWritingSectors(ucCon, uCurrentLba, uCurrentCount, uCurrentAddr);

		while(g_oaATAInform[ucCon].bIsXferDone != TRUE);
		g_oaATAInform[ucCon].bIsXferDone = FALSE;

		uRound++;
	}

	Disp("Write Done\n");

	uRemainderCount = uSector;
	uRound = 0;	
	
	while(uRemainderCount != 0) {
		if(uRemainderCount>256) {
			uCurrentCount = 256; //0 means 256
			uRemainderCount -= 256;
		} else {
			uCurrentCount = uRemainderCount;
			uRemainderCount = 0;
		}
		uCurrentLba = uDeviceLBA + uRound*256;
		uCurrentAddr = (u32)(g_oaATAInform[ucCon].puATAReadBuf + uRound*256*512);

		ATA_StartReadingSectors(ucCon, uCurrentLba, uCurrentCount, uCurrentAddr);

		while(g_oaATAInform[ucCon].bIsXferDone != TRUE) ;
		g_oaATAInform[ucCon].bIsXferDone = FALSE;	

		uRound++;
	}
	
	Disp("Read Done\n");	

	if (Compare((u32)(g_oaATAInform[ucCon].puATAWriteBuf), (u32)(g_oaATAInform[ucCon].puATAReadBuf), uSector*128) == FALSE)
	{
		Disp("Error detected\n");
		Dump32((u32)(g_oaATAInform[ucCon].puATAReadBuf), uSector*128);
	}
	else
	{
		Disp("Write/Read operation in UDMA mode is OK\n");
	}

	INTC_Disable( NUM_CFC);
	
	ATA_CloseMedia(ucCon);
}

//////////
// Function Name : ATA_OpenMedia
// Function Description : 
//   This function opens ATA media.
// Input : ucCon - ATA Controller Number 
//		eATAMode - PIO/PIOCPU/PDMA/UDMA
// Output : NONE
// Version : v0.1 
bool ATA_OpenMedia(u8 ucCon, eATA_MODE_6400 eAtaMode)
{
	eATA_MODE_6400	eMode = eATA_MODE_PIO;

	Disp("ATA Mode : %s\n", ATA_GetModeName(eAtaMode));
	
	ATA_IdentifyDevice(ucCon);
	
	if ( eAtaMode == eATA_MODE_NONE )
	{
		if ( g_oaATAInform[ucCon].eMaxUdmaMode == 0 )
		{
			eMode = eATA_MODE_PIO;
		}
		else
		{
			eMode = eATA_MODE_UDMA;
		}
	} 
	else 
	{
		eMode = eAtaMode ;
	}		

	g_oaATAInform[ucCon].eAtaMode = eMode;

	switch(eMode)
	{
		case eATA_MODE_PIOCPU :
		case eATA_MODE_PIODMA :
			ATA_SetPIOMode(ucCon, g_oaATAInform[ucCon].eMaxPioMode);
			break;
		case eATA_MODE_UDMA :
			ATA_SetPIOMode(ucCon, eATA_PIO0);
			ATA_SetUdmaMode(ucCon, g_oaATAInform[ucCon].eMaxUdmaMode);
			break;
		default :
			Disp ("Invalid ATA Mode!!\n");
			return false;
	}
	return true;
}

//////////
// Function Name : ATA_CloseMedia
// Function Description : 
//   This function opens ATA media.
// Input : ucCon - ATA Controller Number 
//		eATAMode - PIO/PIOCPU/PDMA/UDMA
// Output : NONE
// Version : v0.1 
bool ATA_CloseMedia(u8 ucCon)
{
	return true;
}

void ATA_TestPDmaMode_Int_for_EBI(void)
//void ATA_TestPioDmaMode(void)
{
	u32		uDeviceLBA	= 0;
	u32		uSector		= 0;
	u32		uLoopCnt 	= 0;

	uDeviceLBA = 0;
	uSector = 100;

	for (uLoopCnt=0; uLoopCnt < uSector*512; uLoopCnt++)
	{
		CF_SetMem(eBYTE, (u32)((u8*)g_oaATAInform[g_ucATAConNum].puATAReadBuf + uLoopCnt), 0);
		CF_SetMem(eBYTE, (u32)((u8*)g_oaATAInform[g_ucATAConNum].puATAWriteBuf + uLoopCnt), (uLoopCnt+2)%256);
	}

	Disp("Press Enter \n");	
	getchar();

	ATA_WriteBlocks(g_ucATAConNum, uDeviceLBA, uSector, (u32)(g_oaATAInform[g_ucATAConNum].puATAWriteBuf));
	ATA_ReadBlocks(g_ucATAConNum, uDeviceLBA, uSector, (u32)(g_oaATAInform[g_ucATAConNum].puATAReadBuf));

	if (Compare((u32)(g_oaATAInform[g_ucATAConNum].puATAWriteBuf), (u32)(g_oaATAInform[g_ucATAConNum].puATAReadBuf), uSector*128) == FALSE)
	{
		Disp("Error detected\n");
		Dump32((u32)(g_oaATAInform[g_ucATAConNum].puATAReadBuf), uSector*128);
	}
	else
	{
		Disp("Write/Read operation is OK\n");
	}

}


void	ATA_TestUDmaMode_Int_for_EBI(void)
{
	u32		uDeviceLBA	= 0;
	u32		uSector		= 0;
	u32		uLoopCnt 	= 0;

	u32		uCurrentCount;
	u32		uRemainderCount;
	u32		uCurrentLba;
	u32		uCurrentAddr;
	u32		uRound;
	u8		ucCon = g_ucATAConNum;

	uDeviceLBA = 0;
	uSector = 	100;

	for (uLoopCnt=0; uLoopCnt < uSector*512; uLoopCnt++)
	{
		CF_SetMem(eBYTE, (u32)((u8*)g_oaATAInform[ucCon].puATAReadBuf + uLoopCnt), 0);
		CF_SetMem(eBYTE, (u32)((u8*)g_oaATAInform[ucCon].puATAWriteBuf + uLoopCnt), (uLoopCnt+5)%256);
	}

	while(1)
	{
		g_oaATAInform[ucCon].bIsXferDone = FALSE;

		ATA_ClearAllInterrupt(ucCon);

		INTC_SetVectAddr( NUM_CFC, Isr_AtaDma);
		INTC_Enable( NUM_CFC);

		// Max transfer block count per command is 256.
		uRemainderCount = uSector;
		uRound = 0;	
		
		while(uRemainderCount != 0) {
			if(uRemainderCount>256) {
				uCurrentCount = 256; //0 means 256
				uRemainderCount -= 256;
			} else {
				uCurrentCount = uRemainderCount;
				uRemainderCount = 0;
			}
			uCurrentLba = uDeviceLBA + uRound*256;
			uCurrentAddr = (u32)(g_oaATAInform[ucCon].puATAWriteBuf + uRound*256*512);
#if 0
			ATA_StartWritingBlocks(ucCon, uCurrentLba, uCurrentCount, uCurrentAddr);
#else
			ATA_StartWritingSectors(ucCon, uCurrentLba, uCurrentCount, uCurrentAddr);
#endif
			while(g_oaATAInform[ucCon].bIsXferDone != TRUE);
			g_oaATAInform[ucCon].bIsXferDone = FALSE;

			uRound++;
		}
	}
}

#define NAND_DMA_TEST 1
#define UDMA_TEST 1
#define PDMA_TEST 1

//////////
// Function Name : ATA_TestUDmaMode_Int_for_AtaBug
// Function Description : 
//   This function tests  function of ATA.
// Input : NONE
// Output : NONE
// Version : v0.1 
extern void NANDT_Init(void);
void	ATA_TestUDmaMode_Int_for_AtaBug(void)
{
	u32		uDeviceLBA	= 0;
	u32		uLoopCnt 	= 0;
	u32		uTempLoopCnt 	= 0;

	u8		ucCon = g_ucATAConNum;

	u32 uBlock = 0;
	u32 uPage = 0;
	

#if (NAND_DMA_TEST==1)
	//-------- Nand Flash setting --------------
	for(uLoopCnt=0 ; uLoopCnt<NAND_DATA_SIZE ; uLoopCnt++)
		*(unsigned char *)(0x52000000+uLoopCnt) = eATA_XFR_CMD_CONTINUE;
	for(uLoopCnt=0 ; uLoopCnt<NAND_SPARE_16 ; uLoopCnt++)
		aSpareBuffer[uLoopCnt] = 0xFF;

	uBlock = 50;
	uPage = 0;

	NANDT_Init();
#endif
#if (UDMA_TEST==1)
	ATA_OpenMedia(ucCon, eATA_MODE_UDMA);

	Disp("\nInput device sector address[max: 0x%x]\n",g_oaATAInform[ucCon].uMaxSectors);
	uDeviceLBA = (u32)GetIntNum();

	for (uLoopCnt=0; uLoopCnt < 512; uLoopCnt++)
	{
		CF_SetMem(eBYTE, (u32)((u8*)g_oaATAInform[ucCon].puATAReadBuf + uLoopCnt), 0);
		CF_SetMem(eBYTE, (u32)((u8*)g_oaATAInform[ucCon].puATAWriteBuf + uLoopCnt), (uLoopCnt+5)%256);
	}

	g_oaATAInform[ucCon].bIsXferDone = FALSE;

	ATA_ClearAllInterrupt(ucCon);

	INTC_SetVectAddr( NUM_CFC, Isr_AtaDma);
	INTC_Enable( NUM_CFC);

#if 0
			ATA_StartWritingBlocks(ucCon, uCurrentLba, uCurrentCount, uCurrentAddr);
#else
			ATA_StartWritingSectors(ucCon, uDeviceLBA, 1, (u32)g_oaATAInform[ucCon].puATAWriteBuf);
#endif

	while(g_oaATAInform[ucCon].bIsXferDone != TRUE);
	g_oaATAInform[ucCon].bIsXferDone = FALSE;
#endif
#if (NAND_DMA_TEST==1)
	NAND_WritePageSLCSetup(0, uBlock, uPage);
	EBI_SetDMAParams(eMEM_NAND);
	// Set LLI parameters for DMA loop operation
	SMC_SetLLI(g_oaEBIInform[eMEM_NAND].uSrcAddr, g_oaEBIInform[eMEM_NAND].uDstAddr, 
				(DATA_SIZE)g_oaEBIInform[eMEM_NAND].eDataSz , (BURST_MODE)g_oaEBIInform[eMEM_NAND].eBurstMode, g_oaEBIInform[eMEM_NAND].uDataCnt);

	DMACH_Start(&g_oaEBIInform[eMEM_NAND].oEBIDma);	// NAND DMA Start

#endif	
#if (UDMA_TEST==1)
	uLoopCnt = 0;
	while(1)
	{
		uLoopCnt++;
		if (uLoopCnt == 0xffffffff) uLoopCnt = 0;
		for(uTempLoopCnt = 0; uTempLoopCnt < uLoopCnt; uTempLoopCnt++) ;

#if 0
		ATA_StartReadingBlocks(ucCon, uDeviceLBA, 1, (u32)g_oaATAInform[ucCon].puATAReadBuf);
#else
		ATA_StartReadingSectors(ucCon, uDeviceLBA, 1, (u32)g_oaATAInform[ucCon].puATAReadBuf);
#endif
		
		while(g_oaATAInform[ucCon].bIsXferDone != TRUE);
		g_oaATAInform[ucCon].bIsXferDone = FALSE;

		if (Compare((u32)(g_oaATAInform[ucCon].puATAWriteBuf), (u32)(g_oaATAInform[ucCon].puATAReadBuf), 1) == FALSE)
		{
			Disp("Error detected\n");
			Dump32((u32)(g_oaATAInform[ucCon].puATAReadBuf), 128);
			break;
		}
		else
		{
			Disp("O");
		}		
	}
	NAND_WritePageSLCClose(0, aSpareBuffer);
	EBI_CloseDMA(eMEM_NAND);

	INTC_Disable( NUM_CFC);
	
	ATA_CloseMedia(ucCon);
#endif	
}