ata_test.c

s3c6400 ADS下官方测试程序

/**************************************************************************************
* 
*	Project Name : S3C6400 Validation
*
*	Copyright 2006 by Samsung Electronics, Inc.
*	All rights reserved.
*
*	Project Description :
*		This software is only for validating functions of the S3C6400.
*		Anybody can use this software without our permission.
*  
*--------------------------------------------------------------------------------------
* 
*	File Name : ata_test.c
*  
*	File Description : This file implements PIO/UDMA mode test functions of CF Controller.
*
*	Author : Sunil,Roe
*	Dept. : AP Development Team
*	Created Date : 2007/1/26
*	Version : 0.1 
* 
*	History
*	- Created(Sunil,Roe 2007/1/26)
*   
**************************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include "system.h"
#include "library.h"
#include "intc.h"
#include "timer.h"
#include "ata.h"
#include "cf.h"
#include "gpio.h"
#include "nand.h"
#include "dma.h"
#include "sromc.h"

#define NAND_DATA_SIZE	NAND_PAGE_512

// global variables
u8 g_ucOpMode;
u8 g_ucATAConNum;
volatile ATA_oInform	g_oaATAInform[ATA_CONNUM];

extern EBI_oInform	g_oaEBIInform[];
extern u8 aBuffer[];
extern u8 aSpareBuffer[];

void Set_Ata_Cmd_START(void);
void Set_Ata_Cmd_STOP(void);
void Set_Ata_Cmd_ABORT(void);
void Set_Ata_Cmd_CONTINUE(void);

// function declaration
void ATA_Test(void);
void ATA_TestChangeModeToAta(void);
void ATA_TestReset(void);
void ATA_PrintDeviceInfo(void);
void ATA_TestBasicWriteRead(void);
void ATA_TestPioCpuMode(void);
void ATA_TestPioCpuModeRead(void);
void ATA_ClearPioCpuMode(void);
void ATA_TestPioDmaMode(void);
void	ATA_TestPioDmaModeWrite(void);
void	ATA_TestPioDmaModeRead(void);
void ATA_TestUdmaMode(void);
void	ATA_TestUdmaModeRead(void);
void ATA_TestPioDmaMode_Int(void);
void	ATA_TestUDmaMode_Int(void);
void ATA_AgingTestPioDmaMode(void);
void	ATA_TestUDmaMode_Int_for_AtaBug(void);
bool ATA_OpenMedia(u8 ucCon, eATA_MODE_6400 eAtaMode);
bool ATA_CloseMedia(u8 ucCon);

const testFuncMenu g_aATATestFunc[]=
{
		ATA_TestChangeModeToAta,			"Change mode to ATA",	
		ATA_TestReset,						"Reset ATA device\n",

		ATA_PrintDeviceInfo,					"Print ATA Device Information",
		ATA_TestBasicWriteRead,				"Basic Write/Read test\n",
		
//		ATA_ClearPioCpuMode,				"PIO_CPU mode Clear test",
		ATA_TestPioCpuMode,				"PIO_CPU mode Write/Read test",
		ATA_TestPioCpuModeRead,			"PIO_CPU mode Read test",		
		ATA_TestPioDmaMode,				"PIO_DMA mode Write/Read test [Polling mode]",
//		ATA_TestPioDmaModeWrite,			"PIO_DMA mode Write test [Polling mode]",
		ATA_TestPioDmaModeRead,			"PIO_DMA mode Read test [Polling mode]",
		ATA_TestUdmaMode,					"UDMA mode Write/Read test [Polling mode]",
		ATA_TestUdmaModeRead,			"UDMA mode Read test [Polling mode]\n",

		ATA_TestPioDmaMode_Int,			"PIO_DMA Write/Read test [Interrupt mode]",
		ATA_TestUDmaMode_Int,				"UDMA Write/Read test [Interrupt mode]\n",

		ATA_AgingTestPioDmaMode,			"PIO_DMA mode Write/Read Aging test [Polling mode]",
//		ATA_TestUDmaMode_Int_for_AtaBug,		"UDMA Write/Read test for ATA Bug[Interrupt mode]",		
		0,0
};


//////////
// Function Name : ATA_Test
// Function Description : This function prints out ATA test functions through UART.
// Input : 	NONE
// Output : 	NONE
// Version : v0.1
void ATA_Test(void)
{
	u32 uCountFunc = 0;
	s32	iSel = 0;

	GPIO_SetPullUpDownEach(eGPIO_P, eGPIO_14, 2);

	Disp("\n\n================== ATA Function Test =====================\n\n");
	Disp("\nSelect the operation mode : 0)Indirect(default)	1)Direct");
	iSel =GetIntNum();
	Disp("\n");
	if(iSel == -1) 
		g_ucOpMode = INDIRECT_MODE;
	else
		g_ucOpMode = (u8)iSel;

	g_ucATAConNum = ATA_CON0; 
	
	if (!ATA_Init(g_ucATAConNum, g_ucOpMode))
	{
		Disp("Fail to initialize ATA Mode...\n");
		return;
	}

	while(1)
	{
		for (uCountFunc=0; (u32)(g_aATATestFunc[uCountFunc].desc)!=0; uCountFunc++)
			Disp("%2d: %s\n", uCountFunc, g_aATATestFunc[uCountFunc].desc);

		Disp("\nSelect the function to test : ");
		iSel =GetIntNum();
		Disp("\n");
		if(iSel == -1) 
			break;

		if (iSel>=0 && iSel<(sizeof(g_aATATestFunc)/8-1))
			(g_aATATestFunc[iSel].func) ();
	}

//	ATA_ReturnPort(g_ucATAConNum);
	ATA_SetEnable(g_ucATAConNum, DISABLE);
	CF_SetMUXReg(eCF_MUX_OUTPUT_DISABLE, eCF_MUX_CARDPWR_OFF, eCF_MUX_MODE_PCCARD);

}

/*---------------------------------- Test Functions -------------------------------*/
//////////
// Function Name : ATA_TestChangeModeToAta
// Function Description : 
//   This function prints out the information of CF Card.
// Input : NONE
// Output : NONE
// Version : v0.1 
void ATA_TestChangeModeToAta(void)
{
	ATA_ChangeATAMode(g_ucATAConNum);
}

//////////
// Function Name : ATA_TestReset
// Function Description : 
//   This function tests reset function of ATA Controller.
// Input : NONE
// Output : NONE
// Version : v0.1 
void ATA_TestReset(void)
{
	ATA_TestResetAll(g_ucATAConNum);
	if (!ATA_Init(g_ucATAConNum, g_ucOpMode))
	{
		Disp("Fail to initialize ATA Mode...\n");
		return;
	}	
}


void ATA_PrintDeviceInfo(void)
{
	ATA_IdentifyDevice(g_ucATAConNum);
}

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

	ATA_OpenMedia(g_ucATAConNum, eATA_MODE_NONE);

	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+0)%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");
	}
	ATA_CloseMedia(g_ucATAConNum);
}

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

	ATA_OpenMedia(g_ucATAConNum, eATA_MODE_PIOCPU);

	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+1)%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");
	}
	ATA_CloseMedia(g_ucATAConNum);
}

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

	ATA_OpenMedia(g_ucATAConNum, eATA_MODE_PIOCPU);

	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), 0);
	}

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

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

	Disp("CF Mem Clear has been completed.\n");
}

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

	ATA_OpenMedia(g_ucATAConNum, eATA_MODE_PIOCPU);

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

//////////
// Function Name : ATA_TestPioDmaMode
// Function Description : 
//   This function tests  function of ATA.
// Input : NONE
// Output : NONE
// Version : v0.1 
void ATA_TestPioDmaMode(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+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");
	}
	ATA_CloseMedia(g_ucATAConNum);
}

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

	ATA_OpenMedia(g_ucATAConNum, eATA_MODE_PIODMA);

	while(1)
	{
		ATA_InitBuffer(g_ucATAConNum);
		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);
		}

		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\n");
			Dump32((u32)(g_oaATAInform[g_ucATAConNum].puATAReadBuf), uSector*128);
			break;
		}
		else
		{
			Disp("Write/Read operation is OK\n\n");
		}
	}
	ATA_CloseMedia(g_ucATAConNum);
}

//////////
// Function Name : ATA_TestPioDmaModeWrite
// Function Description : 
//   This function tests  function of ATA.
// Input : NONE
// Output : NONE
// Version : v0.1 
void ATA_TestPioDmaModeWrite(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+2)%256);
	}

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

	ATA_WriteBlocks(g_ucATAConNum, uDeviceLBA, uSector, (u32)(g_oaATAInform[g_ucATAConNum].puATAWriteBuf));
	ATA_CloseMedia(g_ucATAConNum);
	Disp("To Write to CF Memory has been successful.\n");
}

//////////
// Function Name : ATA_TestPioDmaModeRead
// Function Description : 
//   This function tests  function of ATA.
// Input : NONE
// Output : NONE
// Version : v0.1 
void	ATA_TestPioDmaModeRead(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);
	}

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

//////////
// Function Name : ATA_TestUdmaMode
// Function Description : 
//   This function tests  function of ATA.
// Input : NONE
// Output : NONE
// Version : v0.1 
void ATA_TestUdmaMode(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);
		CF_SetMem(eBYTE, (u32)((u8*)g_oaATAInform[g_ucATAConNum].puATAWriteBuf + uLoopCnt), (uLoopCnt+3)%256);
	}

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