sdcarddriver.c

凌阳32位单片机开发的小游戏

#include "Include\SDCardDriver.h"



// SDCard
	    #define DMA_M2P					0x00000000
		#define DMA_P2M					0x00000001
		#define DMA_AUTO				0x00000000
		#define DMA_REQ					0x00000002
		#define DMA_CON					0x00000000
		#define DMA_FIX					0x00000004
		#define DMA_SINGLE_BUF			0x00000000
		#define DMA_DOUBLE_BUF			0x00000008
		#define DMA_8BIT				0x00000000
		#define DMA_16BIT				0x00000010
		#define DMA_32BIT				0x00000020
		#define DMA_32BIT_BURST			0x00000030
		#define DMA_IRQOFF				0x00000000
		#define DMA_IRQON				0x00000040
		#define DMA_OFF					0x00000000
		#define DMA_ON					0x00000080

U32		rca;
S32 	g_sd_dmabusy;

S32		SDCardTotalSector;
S32		gSDCardInsert;
S32		gSDCardPresent;
S32		gSDCardWriteProtect;


S32 SDDrv_ReadSector(U32 addr, U32 blocknum, U8 *outaddr);
S32 SDDrv_WriteSector(U32 addr, U32 blocknum, U8 *outaddr);
S32 SDDrv_Initial(void);
S32 SDDrv_GetMemSize(void);
S32 SDDrv_GetSpeed(void);

//S32		ReadSectors(U32 block, U32 blocknum, U8 *outaddr);
//S32		WriteSectors(U32 block, U32 blocknum, U8 *outaddr);

S32		DrvSDCReadMulCommand(U32 block);
S32		DrvSDCReadMulData(U8 *outaddr);
S32		DrvSDCReadMulData_INT(U8 *outaddr);
S32		DrvSDCReadMulStop(void);
S32		DrvSDCWriteMulCommand(U32 block);
S32		DrvSDCWriteMulData(U8 *outaddr);
S32		DrvSDCWriteMulData_INT(U8 *outaddr);
S32		DrvSDCWriteMulStop(void);





S32 WaitSDStatus(U32 pollbit)
{
	S32 i;
 
	i = 0;
	do {
		i = i + 1;
		if(!gSDCardInsert)
			return 1;
	} while (((*P_SDC_Status & pollbit) == 0) && (i<60000));
	
	if (i==600000) 
		return 1;

	if ((*P_SDC_Status & (MASK_S_RespIdxError|MASK_S_RespCRCError|MASK_S_DataCRCError|MASK_S_TimeOut)) != 0) 
		return 1;
	return 0;
}	

S32 SDCommand(U32 commandset, U32 arg, U32* outaddr)
{
	// Write Argument First
	*P_SDC_Arg = arg;
	*P_SDC_Command = commandset;
	if (WaitSDStatus(MASK_S_CmdComplete)) 
	{
		*P_SDC_Status = MASK_S_ClrAllBits;
		return 1;
	}
	*outaddr = *P_SDC_Resp;
	*P_SDC_Status = MASK_S_ClrAllBits;
	return 0;
}

S32 SDCommandr2(U32 commandset, U32 arg, U32* outaddr)
{
	S32 i;
	
	// Write Argument First
	*P_SDC_Arg = arg;
	*P_SDC_Command = commandset;
	for (i=0;i<4;i++) 
	{
		if(WaitSDStatus(MASK_S_RespRegFull))
			return 1;
		*outaddr = *P_SDC_Resp;
		outaddr++;
	}
	if (WaitSDStatus(MASK_S_CmdComplete)) 
		return 1;
		
	*P_SDC_Status = MASK_S_ClrAllBits;
	return 0;
}

S32 SDCommandr3(U32 commandset, U32 arg, U32* outaddr)
{
	S32 i;
	
	g_sd_dmabusy = 1;
	
	// Write Argument First
	*P_SDC_Arg = arg;
	*P_SDC_Command = commandset;

	i = 0;
	while ((*P_SDC_Status & MASK_S_DataBufFull) == 0)
	{
		i = i + 1;
		if(i == 600000)
			return 1;
		
		if(!gSDCardInsert)
			return 1;
	}
	
	*outaddr = *P_SDC_DataRx;
	
	i = 0;
	while ((*P_SDC_Status & MASK_S_DataBufFull) == 0)
	{
		i = i + 1;
		if(i == 600000)
			return 1;
		
		if(!gSDCardInsert)
			return 1;
	}
	
	*(outaddr+1) = *P_SDC_DataRx;
	
	if (WaitSDStatus(MASK_S_DataComplete)) 
	{
		*P_SDC_Status = MASK_S_ClrAllBits;
		return 1;
	}

	*P_SDC_Status = MASK_S_ClrAllBits;
	return 0;
}

extern void invalid_cache(U32 addr);

S32 SDDrv_ReadSector(U32 sector, U32 sector_num, U8 *buf)
{
	S32 i, ret;
	
	if(DrvSDCReadMulCommand(sector))
		return 1;
	
	
	for(i=0; i<sector_num; i++)
	{
		ret = DrvSDCReadMulData(buf+i*512);
		//ret = ReadSectors(sector+i, 1, buf+i*512);
		if(ret == 1)
		{
			DrvSDCReadMulStop();	
			return ret;
		}
	}		
	
	if(DrvSDCReadMulStop())
		return 1;
	return 0;
}

S32		DrvSDCReadMulCommand(U32 block)
{
	U32 response[4];
	
	g_sd_dmabusy = 1;

	SDCommand(MASK_CMD7, rca, response);
	
	*P_SDC_Arg = rca;
	*P_SDC_Command = MASK_CMD13;
	
	while((*P_SDC_Status & MASK_S_CmdComplete) == 0x00);
	response[0] = *P_SDC_Resp;
	
	*P_SDC_Status = MASK_S_ClrAllBits;
	
	// Write Argument First
//	*P_SDC_Arg = block<<9;
//	*P_SDC_Command = MASK_CMD18;
//	*P_SDC_Command = MASK_CMD17;
	if(SDCommand(MASK_CMD18,block<<9,response))
		return 1;	
	
	return 0;
}

S32		DrvSDCReadMulData(U8 *outaddr)
{
	U32	i;
	U32 *realaddr;
	
	i=(U32) outaddr;
	if((i & 0x03) == 0x00)
	{
		// USE DMA
		*P_DMA_CR1 = 0x0000;
		
		*P_DMA_AHB_SA1A = (U32)outaddr;
		*P_DMA_AHB_EA1A = (U32)outaddr + (1 << 9) - 4;
		*P_DMA_APB_SA1 = 0x88180004;
	
		//*P_DMA_CR1 = DMA_P2M|DMA_REQ|DMA_FIX|DMA_SINGLE_BUF|DMA_32BIT|DMA_IRQOFF|DMA_ON;
		*P_DMA_CR1 = DMA_P2M|DMA_REQ|DMA_FIX|DMA_SINGLE_BUF|DMA_32BIT_BURST|DMA_IRQOFF|DMA_ON;
	
		// Loop until DMA interrupt is set
		while ((*P_DMA_INT & 0x1) == 0)
		{
			if(!gSDCardInsert)
				return 1;
		}
	
		// Clear Interrupt and Disable DMA channel
		*P_DMA_INT = 0x1;
		*P_DMA_CR1 = 0x0000;	
	}
	else
	{
		// Do Not USE DMA
		U32	DataCount;
		U32	Data;
		
		DataCount=512 >> 2;	// DataCount = 512 Byte / 4
		
		do
		{
			if(WaitSDStatus(MASK_S_DataBufFull))
				return 1;
			Data=*P_SDC_DataRx;
			*outaddr++ = (char) Data;
			Data=Data >> 8;
			*outaddr++ = (char) Data;
			Data=Data >> 8;
			*outaddr++ = (char) Data;
			Data=Data >> 8;
			*outaddr++ = (char) Data;
			
			DataCount--;
		}while(DataCount != 0x00);	
	}
	
	
	realaddr = (U32)outaddr & 0x8fffffff;
	invalid_cache(realaddr);
	
	i = 0;
	while((*P_SDC_Status & MASK_S_DataComplete) == 0x00)
	{
		i++;
		if( i == 0xFFFFFF)
			return 1;
	}
	*P_SDC_Status = MASK_S_ClrAllBits;
	
	return 0;
}

S32		DrvSDCReadMulData_INT(U8 *outaddr)
{
	
	// USE DMA
	*P_DMA_CR1 = 0x0000;
	
	*P_DMA_AHB_SA1A = (U32)outaddr;
	*P_DMA_AHB_EA1A = (U32)outaddr + ( 512 ) - 4;
	*P_DMA_APB_SA1 = 0x88180004;
	
	*P_DMA_CR1 = DMA_P2M|DMA_REQ|DMA_FIX|DMA_SINGLE_BUF|DMA_32BIT_BURST|DMA_IRQON|DMA_ON;
	
	return 0;
}

S32		DrvSDCReadMulStop(void)
{
	U32 response[4];
	U32 loopcnt;
	
	// Stop the controller
	*P_SDC_Command = MASK_CMDSTOP;

	// Loop until controller idle
	while(*P_SDC_Status & MASK_S_ControllerBusy)
		if(!gSDCardInsert)
			return 1;

	*P_SDC_Status = MASK_S_ClrAllBits;
	
	// Stop the card
	SDCommand(MASK_CMD12, 0x00000000, response);
	
	
	loopcnt=0;
	do
	{
		if(SDCommand(MASK_CMD13, rca, response))
			return 1;
		loopcnt++;
		
		if(loopcnt == 0xFFFFFF)
			return 1;
		
	} while (response[0] != 0x0900);
	SDCommand(MASK_CMD7, rca, response);
	return 0;
}


/*
S32 ReadSectors(U32 block, U32 blocknum, U8 *outaddr)
//S32 SDDrv_ReadSector(U32 block, U32 blocknum, U8 *outaddr)
{
	U32	i;
	U32 response[4];
	U32 *realaddr;
	U32 loopcnt;
	
	g_sd_dmabusy = 1;

	SDCommand(MASK_CMD7, rca, response);
	// Write Argument First
	*P_SDC_Arg = block<<9;
	*P_SDC_Command = MASK_CMD18;
//	*P_SDC_Command = MASK_CMD17;
	
	i=(U32) outaddr;
	if((i & 0x03) == 0x00)
	{
		// USE DMA
		*P_DMA_AHB_SA1A = (U32)outaddr;
		*P_DMA_AHB_EA1A = (U32)outaddr + (blocknum<<9) - 4;
		*P_DMA_APB_SA1 = 0x88180004;
	
		//*P_DMA_CR1 = DMA_P2M|DMA_REQ|DMA_FIX|DMA_SINGLE_BUF|DMA_32BIT|DMA_IRQOFF|DMA_ON;
		*P_DMA_CR1 = DMA_P2M|DMA_REQ|DMA_FIX|DMA_SINGLE_BUF|DMA_32BIT_BURST|DMA_IRQOFF|DMA_ON;
	
		// Loop until DMA interrupt is set
		while ((*P_DMA_INT & 0x1) == 0)
		{
			if(!gSDCardInsert)
				return 1;
		}
	
		// Clear Interrupt and Disable DMA channel
		*P_DMA_INT = 0x1;
		*P_DMA_CR1 = 0x0000;
		
		
		
	}
	else
	{
		// Do Not USE DMA
		U32	DataCount;
		U32	Data;
		
		DataCount=blocknum<<7;	// DataCount = blocknum * 512 Byte / 4
		
		do
		{
			if(WaitSDStatus(MASK_S_DataBufFull))
				return 1;
			Data=*P_SDC_DataRx;
			*outaddr++ = (char) Data;
			Data=Data >> 8;
			*outaddr++ = (char) Data;
			Data=Data >> 8;
			*outaddr++ = (char) Data;
			Data=Data >> 8;
			*outaddr++ = (char) Data;
			
			DataCount--;
		}while(DataCount != 0x00);
		
		
	}
	
	
	realaddr = (U32)outaddr & 0x8fffffff;
	invalid_cache(realaddr);
	
	if (WaitSDStatus(MASK_S_DataComplete)) 
	{
		*P_SDC_Status = MASK_S_ClrAllBits;
		return 1;
	}
	
	// Stop the controller
	*P_SDC_Command = MASK_CMDSTOP;

	// Loop until controller idle
	while(*P_SDC_Status & MASK_S_ControllerBusy)
		if(!gSDCardInsert)
			return 1;

	*P_SDC_Status = MASK_S_ClrAllBits;
	
	// Stop the card
	SDCommand(MASK_CMD12, 0x00000000, response);
	
	
	loopcnt=0;
	do
	{
		if(SDCommand(MASK_CMD13, rca, response))
			return 1;
		loopcnt++;
		
		if(loopcnt == 60000)
			return 1;
		
	} while (response[0] != 0x0900);
	SDCommand(MASK_CMD7, rca, response);
// 	realaddr = (U32)outaddr & 0x8fffffff;
//	for(i=0; i<128; i++)
//	{
//		readdata = *(realaddr+i);
//		*(outaddr+4*i) = (readdata & 0xff000000) >> 24;
//		*(outaddr+4*i+1) = (readdata & 0x00ff0000) >> 16;
//		*(outaddr+4*i+2) = (readdata & 0x0000ff00) >> 8;
//		*(outaddr+4*i+3) = (readdata & 0x000000ff);
//	}  
	return 0;
}
*/
S32 SDDrv_WriteSector(U32 block, U32 blocknum, U8 *outaddr)
{
	S32 i, ret;
	
	if(DrvSDCWriteMulCommand(block))
		return 1;
	
	for(i=0; i<blocknum; i++)	
	{
		ret = DrvSDCWriteMulData(outaddr+i*512);
		if(ret == 1)
		{
			DrvSDCWriteMulStop();
			return ret;
		}
	}		
	
	if(DrvSDCWriteMulStop())
		return 1;
	
	return 0;
	
}

S32		DrvSDCWriteMulCommand(U32 block)
{
	U32 	response[4];
	
	SDCommand(MASK_CMD7, rca, response);
	g_sd_dmabusy = 1;	
	
	*P_SDC_Arg = rca;
	*P_SDC_Command = MASK_CMD13;
	
	while((*P_SDC_Status & MASK_S_CmdComplete) == 0x00);
	response[0] = *P_SDC_Resp;
	
	*P_SDC_Status = MASK_S_ClrAllBits;
	
	// Write Argument First
//	*P_SDC_Arg = block<<9;
//	*P_SDC_Command = MASK_CMD25;
	if(SDCommand(MASK_CMD25,block<<9,response))
		return 1;