⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 pccard.c

📁 s3c6400 ADS下官方测试程序
💻 C
📖 第 1 页 / 共 3 页
字号:
🔍
123 

	PCCARD_SetRegValue(ucCon, ePCCARD_CNFG_STATUS, uRegValue);		
}

//////////
// Function Name : PCCARD_SetINTMask
// Function Description : This function sets up PCCARD Interrupt Mask Register.
// Input : 	ucCon 		- PCCARD Controller Number
//			ucMaskFlag	- MASK/UNMASK
// Output : 	NONE
// Version : v0.1
void PCCARD_SetINTMask(u8 ucCon, u8 ucMaskFlag)
{
	u32		uRegValue = 0;

	uRegValue = PCCARD_GetRegValue(ucCon, ePCCARD_INTMSK_SRC);
	uRegValue = uRegValue & ~(0x7<< 8 ) | (ucMaskFlag<<10) | (ucMaskFlag<<9) | (ucMaskFlag<<8);		

	PCCARD_SetRegValue(ucCon, ePCCARD_INTMSK_SRC, uRegValue);		
}

/*---------------------------------- APIs of PCCARD_ATTR Registers ---------------------------------*/
/*---------------------------------- APIs of PCCARD_IO Registers ---------------------------------*/
/*---------------------------------- APIs of PCCARD_COMM Registers ---------------------------------*/
//////////
// Function Name : PCCARD_SetINTMask
// Function Description : This function sets up PCCARD Interrupt Mask Register.
// Input : 	ucCon 			- PCCARD Controller Number
//			ucHoldTiming		- Hold timing value
//			ucCmdTiming		- Cmd timing value
//			ucSetupTiming	- Setup timing value
// Output : 	NONE
// Version : v0.1
void PCCARD_SetCardAccessTiming(u8 ucCon, u8 ucHoldTiming, u8 ucCmdTiming, u8 ucSetupTiming)
{
	u32		uRegValue = 0;

	// Timing Hold, Command, Setup in attr mem mode
	uRegValue = PCCARD_GetRegValue(ucCon, ePCCARD_ATTR);
	uRegValue = (ucHoldTiming<<16)|(ucCmdTiming<<8)|(ucSetupTiming);	
	PCCARD_SetRegValue(ucCon, ePCCARD_ATTR, uRegValue);		
	// Timing Hold, Command, Setup in IO mode
	uRegValue = PCCARD_GetRegValue(ucCon, ePCCARD_IO);
	uRegValue = (ucHoldTiming<<16)|(ucCmdTiming<<8)|(ucSetupTiming);	
	PCCARD_SetRegValue(ucCon, ePCCARD_IO, uRegValue);		
	// Timing Hold, Command, Setup in comm mem mode
	uRegValue = PCCARD_GetRegValue(ucCon, ePCCARD_COMM);
	uRegValue = (ucHoldTiming<<16)|(ucCmdTiming<<8)|(ucSetupTiming);	
	PCCARD_SetRegValue(ucCon, ePCCARD_COMM, uRegValue);		
}

/*---------------------------------- APIs of general PCCARD ---------------------------------*/

//////////
// Function Name : PCCARD_SetSFRBaseAddr
// Function Description : This function sets up the base address of PCCARD Registers.
// Input : 	ucCon		- PCCRAD controller number
// Output : 	uBaseAddress	- the baseaddress of PCCARD registers
// Version : v0.1
void PCCARD_SetSFRBaseAddr(u8 ucCon, u32 uBaseAddress)
{
	g_paPCCARDSFRBase[ucCon] = (void *)uBaseAddress;
}

//////////
// Function Name : PCCARD_GetRegAddr
// Function Description : This function gets the address of PCCARD Registers.
// Input : 	ucPCCARDRegId		- the Id of PCCARD Registers
// Output : 	*puPCCARDReg		- the value of specified register
// Version : v0.1
u32 PCCARD_GetRegAddr(u8 ucCon, ePCCARD_Id uPCCARDRegId)
{
	volatile u32 *	puPCCARDBaseAddr;
	volatile u32 *	puPCCARDReg;	
	u32			uPCCARDRegAddr = 0;

	puPCCARDBaseAddr			= &(PCCARD(ucCon)->rrPCCARD_CFG);
	puPCCARDReg				= puPCCARDBaseAddr + uPCCARDRegId;

	uPCCARDRegAddr			= (u32)&puPCCARDReg;
	return uPCCARDRegAddr;	
}

//////////
// Function Name : PCCARD_GetRegValue
// Function Description : This function gets the value of PCCARD Registers.
// Input : 	ucPCCARDRegId		- the Id of PCCARD Registers
// Output : 	*puPCCARDReg		- the value of specified register
// Version : v0.1
u32 PCCARD_GetRegValue(u8 ucCon, ePCCARD_Id uPCCARDRegId)
{
	volatile u32 *	puPCCARDBaseAddr;
	volatile u32 *	puPCCARDReg;	

	puPCCARDBaseAddr			= &(PCCARD(ucCon)->rrPCCARD_CFG);
	puPCCARDReg				= puPCCARDBaseAddr + uPCCARDRegId;

	return *puPCCARDReg;	
}

//////////
// Function Name : PCCARD_SetRegValue
// Function Description : This function sets the value of PCCARD Registers.
// Input : 	ucPCCARDRegId		- the Id of PCCARD Registers
//			uValue			- the value of register
// Output : 	NONE
// Version : v0.1
void PCCARD_SetRegValue(u8 ucCon, ePCCARD_Id uPCCARDRegId, u32 uValue)
{
	volatile u32 *	puPCCARDBaseAddr;
	volatile u32 *	puPCCARDReg;	

	puPCCARDBaseAddr		= &(PCCARD(ucCon)->rrPCCARD_CFG);
	puPCCARDReg			= puPCCARDBaseAddr + uPCCARDRegId;

	*puPCCARDReg			= uValue;
}

//=========================================================================
//					          	          TASK FILE REGISTER AREA
//=========================================================================
/*---------------------------------- APIs of Task File Registers of memory/IO1/IO2/IO3 mode in PCCARD mode  ---------------------------------*/
//////////
// Function Name : PCCARD_ChangePCCARDMode
// Function Description : 
//   This function changes PCCARD mode by matching the address of Task File Registers.
// Input : 	ucCon - PCCARD Controller Number 
//			ePccardMode		- MEM_MODE/IO1_MODE/IO2_MODE/IO3_MODE
// Output : NONE
// Version : v0.1 
void PCCARD_ChangePCCARDMode(u8 ucCon, ePCCARD_MODE ePccardMode)
{
	switch(ePccardMode)
	{
		// contiguous I/O map
		case ePCCARD_CONTIGUOUS_IO :
			g_oaPCCARDInform[ucCon].PCCARD_DATA 		= (PCCARD_IO_BASE + 0x00);
			g_oaPCCARDInform[ucCon].PCCARD_FEATURE	= (PCCARD_IO_BASE + 0x01);
			g_oaPCCARDInform[ucCon].PCCARD_SECTOR	= (PCCARD_IO_BASE + 0x02);
			g_oaPCCARDInform[ucCon].PCCARD_LOWLBA	= (PCCARD_IO_BASE + 0x03);
			g_oaPCCARDInform[ucCon].PCCARD_MIDLBA	= (PCCARD_IO_BASE + 0x04);
			g_oaPCCARDInform[ucCon].PCCARD_HIGHLBA	= (PCCARD_IO_BASE + 0x05);
			g_oaPCCARDInform[ucCon].PCCARD_DEVICE	= (PCCARD_IO_BASE + 0x06);
			g_oaPCCARDInform[ucCon].PCCARD_STATUS	= (PCCARD_IO_BASE + 0x07);
			g_oaPCCARDInform[ucCon].PCCARD_COMMAND	= (PCCARD_IO_BASE + 0x07);			

			PCCARD_SetTaskFileBaseAddr(ucCon, (PCCARD_IO_BASE + 0x00));
			break;
		// Primary I/O map
		case ePCCARD_PRIMARY_IO:
			g_oaPCCARDInform[ucCon].PCCARD_DATA 		= (PCCARD_IO_BASE + 0x1F0);
			g_oaPCCARDInform[ucCon].PCCARD_FEATURE	= (PCCARD_IO_BASE + 0x1F1);
			g_oaPCCARDInform[ucCon].PCCARD_SECTOR	= (PCCARD_IO_BASE + 0x1F2);
			g_oaPCCARDInform[ucCon].PCCARD_LOWLBA	= (PCCARD_IO_BASE + 0x1F3);
			g_oaPCCARDInform[ucCon].PCCARD_MIDLBA	= (PCCARD_IO_BASE + 0x1F4);
			g_oaPCCARDInform[ucCon].PCCARD_HIGHLBA	= (PCCARD_IO_BASE + 0x1F5);
			g_oaPCCARDInform[ucCon].PCCARD_DEVICE	= (PCCARD_IO_BASE + 0x1F6);
			g_oaPCCARDInform[ucCon].PCCARD_STATUS	= (PCCARD_IO_BASE + 0x1F7);
			g_oaPCCARDInform[ucCon].PCCARD_COMMAND	= (PCCARD_IO_BASE + 0x1F7);			

			PCCARD_SetTaskFileBaseAddr(ucCon, (PCCARD_IO_BASE + 0x1F0));
			break;
		// Secondary I/O map
		case ePCCARD_SECONDARY_IO :
			g_oaPCCARDInform[ucCon].PCCARD_DATA 		= (PCCARD_IO_BASE + 0x170);
			g_oaPCCARDInform[ucCon].PCCARD_FEATURE	= (PCCARD_IO_BASE + 0x171);
			g_oaPCCARDInform[ucCon].PCCARD_SECTOR	= (PCCARD_IO_BASE + 0x172);
			g_oaPCCARDInform[ucCon].PCCARD_LOWLBA	= (PCCARD_IO_BASE + 0x173);
			g_oaPCCARDInform[ucCon].PCCARD_MIDLBA	= (PCCARD_IO_BASE + 0x174);
			g_oaPCCARDInform[ucCon].PCCARD_HIGHLBA	= (PCCARD_IO_BASE + 0x175);
			g_oaPCCARDInform[ucCon].PCCARD_DEVICE	= (PCCARD_IO_BASE + 0x176);
			g_oaPCCARDInform[ucCon].PCCARD_STATUS	= (PCCARD_IO_BASE + 0x177);
			g_oaPCCARDInform[ucCon].PCCARD_COMMAND	= (PCCARD_IO_BASE + 0x177);			

			PCCARD_SetTaskFileBaseAddr(ucCon, (PCCARD_IO_BASE + 0x170));
			break;
		// defulat : PCCARD_MEM_MODE
		case ePCCARD_COMMON_MEMORY :
			g_oaPCCARDInform[ucCon].PCCARD_DATA 		= (PCCARD_MEM_BASE + 0x00);
			g_oaPCCARDInform[ucCon].PCCARD_FEATURE	= (PCCARD_MEM_BASE + 0x01);
			g_oaPCCARDInform[ucCon].PCCARD_SECTOR	= (PCCARD_MEM_BASE + 0x02);
			g_oaPCCARDInform[ucCon].PCCARD_LOWLBA	= (PCCARD_MEM_BASE + 0x03);
			g_oaPCCARDInform[ucCon].PCCARD_MIDLBA	= (PCCARD_MEM_BASE + 0x04);
			g_oaPCCARDInform[ucCon].PCCARD_HIGHLBA	= (PCCARD_MEM_BASE + 0x05);
			g_oaPCCARDInform[ucCon].PCCARD_DEVICE	= (PCCARD_MEM_BASE + 0x06);
			g_oaPCCARDInform[ucCon].PCCARD_STATUS	= (PCCARD_MEM_BASE + 0x07);
			g_oaPCCARDInform[ucCon].PCCARD_COMMAND	= (PCCARD_MEM_BASE + 0x07);			

			PCCARD_SetTaskFileBaseAddr(ucCon, (PCCARD_MEM_BASE + 0x00));
			break;
	}
	PCCARD_SetCardMode(ucCon, 0, ePccardMode);	// 0 is offset of  PCCARD_CONFIG_OPTION register
}

//////////
// Function Name : PCCARD_SetTaskFileBaseAddr
// Function Description : This function sets up the base address of PCCARD Registers.
// Input : 	ucCon		- PCCRAD controller number
// Output : 	uBaseAddress	- the baseaddress of PCCARD Task File registers
// Version : v0.1
void PCCARD_SetTaskFileBaseAddr(u8 ucCon, u32 uBaseAddress)
{
	g_paPCCARDTaskFileBase[ucCon] = (void *)uBaseAddress;
}

//////////
// Function Name : PCCARD_GetTaskFileRegValue
// Function Description : This function gets the value of PCCARD Registers.
// Input : 	uPCCARDTaskFileRegId		- the Id of PCCARD Task File Registers
// Output : 	*puPCCARDReg			- the value of specified register
// Version : v0.1
u8 PCCARD_GetTaskFileRegValue(u8 ucCon, eCF_TASKFILE_Id uPCCARDTaskFileRegId)
{
	volatile u8 *	puPCCARDBaseAddr;
	volatile u8 *	puPCCARDReg;	

	puPCCARDBaseAddr			= &(PCCARD_TASKFILE(ucCon)->rPCCARD_DATA);
	puPCCARDReg				= puPCCARDBaseAddr + uPCCARDTaskFileRegId;
//	printf("[GET]puPCCARDBase : 0x%x, RegID:0x%x, DestAddr : 0x%x, Result : 0x%x\n", puPCCARDBaseAddr, uPCCARDTaskFileRegId, puPCCARDReg, *puPCCARDReg);	
	return *puPCCARDReg;	
}

u16 PCCARD_GetTaskFileRegValue16(u8 ucCon, eCF_TASKFILE_Id uPCCARDTaskFileRegId)
{
	volatile u16 *	puPCCARDBaseAddr;
	volatile u16 *	puPCCARDReg;	

	puPCCARDBaseAddr			= (u16*)&(PCCARD_TASKFILE(ucCon)->rPCCARD_DATA);
	puPCCARDReg				= puPCCARDBaseAddr + uPCCARDTaskFileRegId;
	return *puPCCARDReg;	
}

//////////
// Function Name : PCCARD_SetTaskFileRegValue
// Function Description : This function clears the value of PCCARD TaskFile Registers.
// Input : 	ucPCCARDRegId		- the Id of PCCARD Registers
//			uValue			- the value of register
// Output : 	NONE
// Version : v0.1
void PCCARD_SetTaskFileRegValue(u8 ucCon, eCF_TASKFILE_Id uPCCARDTaskFileRegId, u32 uValue)
{
	volatile u8 *	puPCCARDBaseAddr;
	volatile u8 *	puPCCARDReg;	
	u8			ucTaskFileRegValue 	= 0;
	
	do
	{
		ucTaskFileRegValue = PCCARD_GetTaskFileRegValue( ucCon, eCF_TASKFILE_STATUS);
	} while (	ucTaskFileRegValue == 0x80 ) ;
	
	puPCCARDBaseAddr		= &(PCCARD_TASKFILE(ucCon)->rPCCARD_DATA);
	puPCCARDReg			= puPCCARDBaseAddr + uPCCARDTaskFileRegId;
	*puPCCARDReg			= uValue;
//	printf("[SET]puPCCARDBase : 0x%x, RegID:0x%x, DestAddr : 0x%x, Value : 0x%x\n", puPCCARDBaseAddr, uPCCARDTaskFileRegId, puPCCARDReg, uValue);	
}

void PCCARD_SetTaskFileRegValue16(u8 ucCon, eCF_TASKFILE_Id uPCCARDTaskFileRegId, u16 uValue)
{
	volatile u16 *	puPCCARDBaseAddr;
	volatile u16 *	puPCCARDReg;	
	u8			ucTaskFileRegValue 	= 0;
	
	do
	{
		ucTaskFileRegValue = PCCARD_GetTaskFileRegValue( ucCon, eCF_TASKFILE_STATUS);
	} while (	ucTaskFileRegValue == 0x80 ) ;
	
	puPCCARDBaseAddr		= (u16*)&(PCCARD_TASKFILE(ucCon)->rPCCARD_DATA);
	puPCCARDReg			= puPCCARDBaseAddr + uPCCARDTaskFileRegId;
	*puPCCARDReg			= uValue;
//	printf("[SET16]puPCCARDBase : 0x%x, RegID:0x%x, DestAddr : 0x%x, Value : 0x%x\n", puPCCARDBaseAddr, uPCCARDTaskFileRegId, puPCCARDReg, uValue);	
}

//////////
// Function Name : PCCARD_ReadBlocks
// Function Description : This function implements block write function to PCCARD TaskFile Registers.
// Input : 	ucCon		- PCCRAD controller number
//			uDeviceLba	- LBA number
//			uBlockCount	- Block number
//			uBufAddr		- Buffer Address
// Output : 	NONE
// Version : v0.1
123

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -