ata.c

s3c6400 ADS下官方测试程序

	ATA_SetRegValue(ucCon, eATA_IRQ, uRegValue);			
}

void ATA_ClearAllInterrupt(u8 ucCon)
{
	u32		uRegValue = 0;

	uRegValue = ATA_GetRegValue(ucCon, eATA_IRQ);
	uRegValue |= (0x1f << 0);

	ATA_SetRegValue(ucCon, eATA_IRQ, uRegValue);			
}
/*---------------------------------- APIs of ATA_CFG Registers ---------------------------------*/
void ATA_SetConfig(u8 ucCon, eATA_MODE_6400 eMode, eATA_DMA_DIR eDmaDir)
{
	switch(eMode)
	{
		case eATA_MODE_PIOCPU : 
			ATA_SetXferMode(ucCon, eATA_MODE_PIOCPU);	// set PIO_CPU class
			break;
		case eATA_MODE_PIODMA : 
			ATA_SetXferMode(ucCon, eATA_MODE_PIODMA);	// set PDMA class
			ATA_SetDMAXferDir(ucCon, eDmaDir);			// DMA read/write mode
			break;
		case eATA_MODE_UDMA : 
			ATA_SetXferMode(ucCon, eATA_MODE_UDMA);	// set UDMA class
			ATA_SetUdmaAutoMode(ucCon, ENABLE);		// set ATA DMA auto mode (enable multi block transfer)
			ATA_SetDMAXferDir(ucCon, eDmaDir);			// DMA read/write mode
			break;
		default :
			break;
	}
}

//////////
// Function Name : ATA_SetUdmaAutoMode
// Function Description : This function sets up UDMA auto mode.
// Input : 	ucCon - ATA Controller Number
//			ucEnFlag - UDMA auto mode Enable/Disable
// Output : 	NONE
// Version : v0.1
void ATA_SetUdmaAutoMode(u8 ucCon, u8 ucEnFlag)
{
	u32		uRegValue = 0;

	uRegValue = ATA_GetRegValue(ucCon, eATA_CFG);
	uRegValue = uRegValue & ~(0x200) | (ucEnFlag << 9);		

	ATA_SetRegValue(ucCon, eATA_CFG, uRegValue);			
}

bool ATA_IsTBufFullContinue(u8 ucCon)
{
	u32		uRegValue = 0;
	bool		bStatus = FALSE;

	uRegValue = ATA_GetRegValue(ucCon, eATA_CFG);
	bStatus = (uRegValue & (0x80)) ? TRUE : FALSE;		

	return bStatus;
}

bool ATA_IsSBufEmptyContinue(u8 ucCon)
{
	u32		uRegValue = 0;
	bool		bStatus = FALSE;

	uRegValue = ATA_GetRegValue(ucCon, eATA_CFG);
	bStatus = (uRegValue & (0x100)) ? TRUE : FALSE;		

	return bStatus;
}

//////////
// Function Name : ATA_SetEndian
// Function Description : This function sets up the endian mode of ATA controller.
// Input : 	ucCon - ATA Controller Number
//			eEndianMode - Little/Big endian
// Output : 	NONE
// Version : v0.1
void ATA_SetEndian(u8 ucCon, eATA_ENDIAN eEndianMode)
{
	u32		uRegValue = 0;

	uRegValue = ATA_GetRegValue(ucCon, eATA_CFG);
	uRegValue = uRegValue & ~(0x40) | (eEndianMode << 6);		

	ATA_SetRegValue(ucCon, eATA_CFG, uRegValue);			
}

//////////
// Function Name : ATA_SetDMAXferDir
// Function Description : This function sets up the DMA direction of ATA controller.
// Input : 	ucCon - ATA Controller Number
//			eDmaDir - DMA transfer direction flag (read DMA/write DMA)
// Output : 	NONE
// Version : v0.1
void ATA_SetDMAXferDir(u8 ucCon, eATA_DMA_DIR eDmaDir)
{
	u32		uRegValue = 0;

	uRegValue = ATA_GetRegValue(ucCon, eATA_CFG);
	uRegValue = uRegValue & ~(0x10) | (eDmaDir << 4);		

	ATA_SetRegValue(ucCon, eATA_CFG, uRegValue);			
}

//////////
// Function Name : ATA_SetIORDY
// Function Description : This function sets up ATA mode.
// Input : 	ucCon - ATA Controller Number
//			eAtaMode - PIO CPU/PIO DMA/UDMA
// Output : 	NONE
// Version : v0.1
void ATA_SetXferMode(u8 ucCon, eATA_MODE_6400 eAtaMode)
{
	u32		uRegValue = 0;

	uRegValue = ATA_GetRegValue(ucCon, eATA_CFG);
	uRegValue = uRegValue & ~(0xc) | (eAtaMode << 2);		

	ATA_SetRegValue(ucCon, eATA_CFG, uRegValue);			
}

//////////
// Function Name : ATA_SetIORDY
// Function Description : This function sets up IORDY of ATA controller.
// Input : 	ucCon - ATA Controller Number
//			ucEnFlag - IORDY Enable/Disable
// Output : 	NONE
// Version : v0.1
void ATA_SetIORDY(u8 ucCon, u8 ucEnFlag)
{
	u32		uRegValue = 0;

	uRegValue = ATA_GetRegValue(ucCon, eATA_CFG);
	uRegValue = uRegValue & ~(0x2) | (ucEnFlag << 1);		

	ATA_SetRegValue(ucCon, eATA_CFG, uRegValue);			
}

//////////
// Function Name : ATA_SetRst
// Function Description : This function sets up reset of ATA controller.
// Input : 	ucCon - ATA Controller Number
//			ucEnFlag - IORDY Enable/Disable
// Output : 	NONE
// Version : v0.1
void ATA_SetRst(u8 ucCon, u8 ucEnFlag)
{
	u32		uRegValue = 0;

	uRegValue = ATA_GetRegValue(ucCon, eATA_CFG);
	uRegValue = uRegValue & ~(0x1) | (ucEnFlag << 0);		

	ATA_SetRegValue(ucCon, eATA_CFG, uRegValue);			
}
/*---------------------------------- APIs of ATA Transfer Registers ---------------------------------*/
//////////
// Function Name : ATA_SetSBufStart
// Function Description : This function sets the start address of source buffer.
// Input : 	ucCon 			- ATA Controller Number
//			uBufAddr			- the start address of source buffer
// Output : 	NONE
// Version : v0.1
void ATA_SetSBufStart(u8 ucCon, u32 uBufAddr)
{
	u32		uRegValue = 0;

	uRegValue = ATA_GetRegValue(ucCon, eATA_SBUF_START);
//	uRegValue = uRegValue & ~(0xfffffffc) | (uBufAddr << 2);		
	uRegValue = uRegValue & ~(0xfffffffc) | (uBufAddr << 0);		

	ATA_SetRegValue(ucCon, eATA_SBUF_START, uRegValue);			
}

//////////
// Function Name : ATA_SetTBufStart
// Function Description : This function sets the start address of target buffer.
// Input : 	ucCon 			- ATA Controller Number
//			uBufAddr			- the target address of source buffer
// Output : 	NONE
// Version : v0.1
void ATA_SetTBufStart(u8 ucCon, u32 uBufAddr)
{
	u32		uRegValue = 0;

	uRegValue = ATA_GetRegValue(ucCon, eATA_TBUF_START);
//	uRegValue = uRegValue & ~(0xfffffffc) | (uBufAddr << 2);		
	uRegValue = uRegValue & ~(0xfffffffc) | (uBufAddr << 0);		

	ATA_SetRegValue(ucCon, eATA_TBUF_START, uRegValue);			
}

//////////
// Function Name : ATA_SetSBufSize
// Function Description : This function sets the start address of source buffer.
// Input : 	ucCon 			- ATA Controller Number
//			uBufAddr			- the start address of source buffer
// Output : 	NONE
// Version : v0.1
void ATA_SetSBufSize(u8 ucCon, u32 uSize)
{
	u32		uRegValue = 0;

	uRegValue = ATA_GetRegValue(ucCon, eATA_SBUF_SIZE);
//	uRegValue = uRegValue & ~(0xffffffe0) | (uSize << 5);		
	uRegValue = uRegValue & ~(0xffffffe0) | (uSize << 0);		

	ATA_SetRegValue(ucCon, eATA_SBUF_SIZE, uRegValue);			
}

//////////
// Function Name : ATA_SetTBufSize
// Function Description : This function sets the start address of target buffer.
// Input : 	ucCon 			- ATA Controller Number
//			uBufAddr			- the start address of target  buffer
// Output : 	NONE
// Version : v0.1
void ATA_SetTBufSize(u8 ucCon, u32 uSize)
{
	u32		uRegValue = 0;

	uRegValue = ATA_GetRegValue(ucCon, eATA_TBUF_SIZE);
//	uRegValue = uRegValue & ~(0xffffffe0) | (uSize << 5);		
	uRegValue = uRegValue & ~(0xffffffe0) | (uSize << 0);		

	ATA_SetRegValue(ucCon, eATA_TBUF_SIZE, uRegValue);			
}

//////////
// Function Name : ATA_SetXfrNum
// Function Description : This function sets the start address of source buffer.
// Input : 	ucCon 			- ATA Controller Number
//			uNum			- Data Transfer number
// Output : 	NONE
// Version : v0.1
void ATA_SetXfrNum(u8 ucCon, u32 uNum)
{
	u32		uRegValue = 0;

	uRegValue = ATA_GetRegValue(ucCon, eATA_XFR_NUM);
//	uRegValue = uRegValue & ~(0xfffffffe) | (uNum << 1);
	uRegValue = uRegValue & ~(0xfffffffe) | (uNum << 0);

	ATA_SetRegValue(ucCon, eATA_XFR_NUM, uRegValue);			
}

/*---------------------------------- APIs of ATA TASK FILE Registers ---------------------------------*/
//////////
// Function Name : ATA_GetTaskFileRegValue
// Function Description : This function gets the value of ATA Registers.
// Input : 	ucCon 				- ATA Controller Number
//			uATATaskFileRegId		- the Id of ATA Task File Registers
// Output : 	*puATAReg			- the value of specified register
// Version : v0.1
u8 ATA_GetTaskFileRegValue(u8 ucCon, eCF_TASKFILE_Id uATATaskFileRegId)
{
	volatile u32 *	puATABaseAddr;
	volatile u8 *	puATAReg;	

	puATABaseAddr			= &(ATA(ucCon)->rrATA_PIO_DTR);
	puATAReg				= (u8 *)(puATABaseAddr + uATATaskFileRegId);
//	Disp("[ATA_GetTaskFileRegValue]puATABase : 0x%x, RegID:0x%x, DestAddr : 0x%x, Result : 0x%x\n", puATABaseAddr, uATATaskFileRegId, puATAReg, *puATAReg);	
	return *puATAReg;	
}

u16 ATA_GetTaskFileRegValue16(u8 ucCon, eCF_TASKFILE_Id uATATaskFileRegId)
{
	volatile u32 *	puATABaseAddr;
	volatile u16 *	puATAReg;	

	puATABaseAddr			= &(ATA(ucCon)->rrATA_PIO_DTR);
	puATAReg				= (u16 *)(puATABaseAddr + uATATaskFileRegId);
//	Disp("[ATA_GetTaskFileRegValue16]puATABase : 0x%x, RegID:0x%x, DestAddr : 0x%x, Result : 0x%x\n", puATABaseAddr, uATATaskFileRegId, puATAReg, *puATAReg);	
	return *puATAReg;	
}
//////////
// Function Name : ATA_SetTaskFileRegValue
// Function Description : This function sets up the value of ATA TaskFile Registers.
// Input : 	ucCon 				- ATA Controller Number
//			uATATaskFileRegId		- the Id of ATA Task File Registers
//			uValue				- the value of register
// Output : 	NONE
// Version : v0.1
void ATA_SetTaskFileRegValue(u8 ucCon, eCF_TASKFILE_Id uATATaskFileRegId, u32 uValue)
{
	volatile u32 *	puATABaseAddr;
	volatile u8 *	puATAReg;	

	ATA_WaitForHostReady(ucCon);
	
	puATABaseAddr		= &(ATA(ucCon)->rrATA_PIO_DTR);
	puATAReg			= (u8 *)(puATABaseAddr + uATATaskFileRegId);
	*puATAReg			= uValue;
//	Disp("[ATA_SetTaskFileRegValue]puATABase : 0x%x, RegID:0x%x, DestAddr : 0x%x, Value : 0x%x\n", puATABaseAddr, uATATaskFileRegId, puATAReg, uValue);	
}

void ATA_SetTaskFileRegValue16(u8 ucCon, eCF_TASKFILE_Id uATATaskFileRegId, u16 uValue)
{
	volatile u32 *	puATABaseAddr;
	volatile u16 *	puATAReg;	

	ATA_WaitForHostReady(ucCon);
	
	puATABaseAddr		= &(ATA(ucCon)->rrATA_PIO_DTR);
	puATAReg			= (u16 *)(puATABaseAddr + uATATaskFileRegId);
	*puATAReg			= uValue;
//	Disp("[ATA_SetTaskFileRegValue16]puATABase : 0x%x, RegID:0x%x, DestAddr : 0x%x, Value : 0x%x\n", puATABaseAddr, uATATaskFileRegId, puATAReg, uValue);	
}
/*---------------------------------- APIs of ATA_FIFO_STATUS Registers ---------------------------------*/
//////////
// Function Name : ATA_WaitForHostReady
// Function Description : This function awaits the ready state of Host.
// Input : 	ucCon 	- ATA Controller Number
// Output : 	NONE
// Version : v0.1
void ATA_WaitForHostReady(u8 ucCon)
{
	u32			ucTaskFileRegValue 	= 0;
	
	do
	{
		ucTaskFileRegValue = ATA_GetRegValue( ucCon, eATA_FIFO_STATUS );
//		Disp("[WaitForHostReady]ucTaskFileRegValue:0x%x\n", ucTaskFileRegValue);
	} while ( (ucTaskFileRegValue >> 28) != 0 ) ;
}

/*---------------------------------- APIs of general ATA ---------------------------------*/

//////////
// Function Name : ATA_GetRegAddr
// Function Description : This function gets the address of ATA Registers.
// Input : 	ucATARegId		- the Id of ATA Registers
// Output : 	*puATAReg		- the value of specified register
// Version : v0.1
u32 ATA_GetRegAddr(u8 ucCon, eATA_Id uATARegId)
{
	volatile u32 *	puATABaseAddr;
	volatile u32 *	puATAReg;	
	u32			uATARegAddr = 0;

	puATABaseAddr			= &(ATA(ucCon)->rrATA_CONTROL);
	puATAReg				= puATABaseAddr + uATARegId;

	uATARegAddr			= (u32)&puATAReg;
	return uATARegAddr;	
}

//////////
// Function Name : ATA_GetRegValue
// Function Description : This function gets the value of ATA Registers.
// Input : 	ucATARegId		- the Id of ATA Registers
// Output : 	*puATAReg		- the value of specified register
// Version : v0.1
u32 ATA_GetRegValue(u8 ucCon, eATA_Id uATARegId)
{
	volatile u32 *	puATABaseAddr;
	volatile u32 *	puATAReg;	

	puATABaseAddr			= &(ATA(ucCon)->rrATA_CONTROL);
	puATAReg				= puATABaseAddr + uATARegId;
//	Disp("[ATA_GetRegValue]ATABaseAddr : 0x%x, ATAId:0x%d, ATAReg: 0x%x, Value:0x%x \n", puATABaseAddr, uATARegId, puATAReg, *puATAReg);
	return *puATAReg;	
}

//////////
// Function Name : ATA_SetRegValue
// Function Description : This function sets the value of ATA Registers.
// Input : 	ucATARegId		- the Id of ATA Registers
//			uValue			- the value of register
// Output : 	NONE
// Version : v0.1
void ATA_SetRegValue(u8 ucCon, eATA_Id uATARegId, u32 uValue)
{
	volatile u32 *	puATABaseAddr;
	volatile u32 *	puATAReg;	

	puATABaseAddr		= &(ATA(ucCon)->rrATA_CONTROL);
	puATAReg			= puATABaseAddr + uATARegId;
//	Disp("[ATA_SetRegValue]ATABaseAddr : 0x%x, ATAReg: 0x%x, Value:0x%x \n", puATABaseAddr, puATAReg, uValue);
	*puATAReg			= uValue;
}

//////////
// Function Name : ATA_GetModeName
// Function Description : 
//   This function returns ATA mode string.
// Input : eATAMode - PIO/PIOCPU/PDMA/UD