sd.c

sd card for pxa270 (在bootloader 下)

#include<windows.h>
#include <ethdbg.h> 
#include "halether.h" 
#include <nkintr.h>
#include <pehdr.h>
//#include "xllp_defs.h"
#include "xllp_mmc.h"
//#include "xllp_pwm.h"
#include <oal_memory.h>
#include "sd.h"
#include <math.h>
#include "fat.h"


//UINT32 databuf[512/4];
typedef struct
{
	UINT CMD;
	UINT ADDR;
	UINT FSIZE;
	UINT BSIZE;
	UINT RATE;
	UINT NOB;          //block number
	UINT DATATRANS;
	BOOL BUSY;
	BOOL READSCR;
	
}mmcStack;


#define SO_SCR 			0x8;  // size of sd scr register
#define SO_BLOCK 		0x200;
#define RCA_MMC_CARD 	0x420000;
#define CMD1_ADDR 		0x200000;

typedef struct{
	UINT32 lresponse[4];
	UINT32 sresponse;
	UINT32 status;
}STATRES;

typedef struct {
	UINT SZ_PROC : 32;
	UINT SD_CARD_TYPE : 16;
	UINT RES2 : 13;
	UINT SECD_MODE : 1;
	UINT DAT_BUS_WIDTH : 2;
} STATUS;

typedef struct {
	UINT SCR_STRUCTURE : 4;
	UINT SD_SPEC : 4;
	UINT DATA_STAT_AFTER_ERASE : 1;
	UINT SD_SECURITY : 3;
	UINT SD_BUS_WIDTH : 4;
	UINT RES2 : 16;
	UINT RES1 : 32;	// RESERVED FOR MANUFACTURER
}SCR;//SCR scr;

typedef struct {
	UINT NU : 1;	// 0- 31
	UINT CRC : 7;
	UINT MDT : 8;
	UINT PSN : 16;
	
	UINT PSNx : 16;	 // 32- 63
	UINT PRV : 8;
	UINT PNM : 8;
	
	UINT PNMx :32;	  // 64- 96
	
	UINT PNMxx : 7;	  //96 - 127
	UINT OID : 16;
	UINT MID : 8;
}MMCCID; 


typedef struct {
	UINT ECC : 2;               // Bits 0-31
	UINT RES1 : 2;
	UINT TMP_WRITE_PROTECT : 1;
	UINT PERM_WRITE_PROTECT : 1;
	UINT COPY : 1;
	UINT RES2 : 1;
	UINT RES3 : 5;
	UINT WRITE_BL_PARTIAL : 1;
	UINT WRITE_BL_LEN : 4;
	UINT R2W_FACTOR : 3;
	UINT DEFAULT_ECC : 2;
	UINT WP_GRP_ENABLE : 1;
	UINT WP_GRP_SIZE : 5;
	UINT ERASE_GRP_MULT : 3;
	
	UINT ERASE_GRP_MULTx : 2;   // Bits 32-63
	UINT ERASE_GRP_SIZE : 5;
	UINT C_SIZE_MULT : 3;
	UINT VDD_W_CURR_MAX : 3;
	UINT VDD_W_CURR_MIN : 3;
	UINT VDD_R_CURR_MAX : 3;
	UINT VDD_R_CURR_MIN : 3;
	UINT C_SIZE : 10;
	
	UINT C_SIZEx : 2;           // Bits 64-95
	UINT RES4 : 2;
	UINT DSR_IMP : 1;
	UINT READ_BLK_MISALIGN : 1;
	UINT WRITE_BLK_MISALIGN : 1;
	UINT READ_BL_PARTIAL : 1;
	UINT READ_BL_LEN : 4;
	UINT CCC : 12;
	UINT TRAN_SPEED : 8;
	
	UINT NSAC : 8;              // Bits 96-127
	UINT TAAC : 8;
	UINT RES5 : 2;
	UINT SPEC_VERS : 4;
	UINT CSD_STRUCTURE : 2;
	UINT RES6 : 8;
}MMCCSD;

union {
    UINT8 b[16];
    UINT16 db[8];
	UINT32 qb[4];
	MMCCSD mmc_csd;
}XsMMC_CSD;

typedef	struct{
	UINT32 block;
	UINT32 *buffer;
	UINT size;
	BOOL mmc;
	UINT32 OCR;
	UINT32 rca;
	MMCCSD *mmc_csd;
	MMCCID *mmc_cid;
	SCR *sd_scr;
	STATUS sd_status;
}MMCSDAttribT;


#define MMCSD_CARD_STATUS_OOR		(1u<<31)	// out of range
#define MMCSD_CARD_STATUS_AE		(1u<<30)	// address error 
#define MMCSD_CARD_STATUS_EP		(1u<<27)	// erase param
#define MMCSD_CARD_STATUS_WPV		(1u<<26)	// write protected block
#define MMCSD_CARD_STATUS_CL		(1u<<25)	// card locked
#define MMCSD_CARD_STATUS_ERR		(1u<<19) 	// general error
#define MMCSD_CARD_STATUS_CS		(0xfu<<9)  	// current state
#define MMCSD_CARD_STATUS_RFD		(1u<<8)  	// ready for data
#define MMCSD_CARD_STATUS_AC		(1u<<5)	 	//  app command
#define MMCSD_CARD_OCR_nBUSY		(1u<<31)	//  app command


typedef enum
{
	DNONE=0,
		WRITE,
		READ
}dataDirection;

typedef struct {
	
	
	UINT NU						: 1;
	UINT CRC 					: 7;
	UINT RES1 					: 2;  
	UINT FILE_FORMAT 			: 2;
	UINT TMP_WRITE_PROTECT 		: 1;
	UINT PERM_WRITE_PROTECT 	: 1;
	UINT COPY 					: 1;
	UINT FILE_FORMAT_GRP 		: 1;
	UINT RES2 					: 5;
	UINT WRITE_BL_PARTIAL 		: 1;
	UINT WRITE_BL_LEN 			: 4;
	UINT R2W_FACTOR 			: 3;
	UINT RES3 					: 2;
	UINT WP_GRP_ENABLE 			: 1;	   // Bits 31-0
	
	UINT WP_GRP_SIZE 			: 7;	 
	UINT SECTOR_SIZE 			: 7;
	UINT ERASE_BLK_EN 			: 1;   
	UINT C_SIZE_MULT 			: 3;
	UINT VDD_W_CURR_MAX 		: 3;
	UINT VDD_W_CURR_MIN 		: 3;
	UINT VDD_R_CURR_MAX 		: 3;
	UINT VDD_R_CURR_MIN 		: 3;
	UINT C_SIZE 				: 2;      // Bits 63-32
	
	UINT C_SIZEx 				: 10;		   
	UINT RES4 					: 2;
	UINT DSR_IMP 				: 1;
	UINT READ_BLK_MISALIGN 		: 1;
	UINT WRITE_BLK_MISALIGN 	: 1;
	UINT READ_BL_PARTIAL 		: 1;
	UINT READ_BL_LEN 			: 4;
	UINT CCC 					: 12;
	UINT TRAN_SPEED 			: 8;	// Bits 64-95   
	
	UINT NSAC 					: 8;              
	UINT TAAC 					: 8;
	UINT RES5 					: 6;
	UINT CSD_STRUCTURE 			: 2;
    
	
	
}SDCSD;



union {
    UINT8 b[16];
    UINT16 db[8];
	UINT32 qb[4];
	SDCSD sd_csd;
}XsSD_CSD;

typedef struct {
	UINT NU : 1;	// 0- 31
	UINT CRC : 7;
	UINT MDT : 12;
	UINT RES1 : 4;
	UINT PSN : 8;
	
	UINT PSNx : 24;	 // 32- 63
	UINT PRV : 8;
	
	UINT PNM : 32;  // 64-96
	
	UINT PNMx : 8;	  //96 - 127
	UINT OID : 16;
	UINT MID : 8;
}SDCID;

union {
    UINT8 b[16];
    UINT16 db[8];
	UINT32 qb[4];
    SDCID sd_cid;
} XsSD_CID;


 BULVERDE_GPIO_REG *v_pGPIOReg=NULL;
 XLLP_MMC_T  *v_pMMCReg=NULL;
 P_XLLP_CLKMGR_T   v_pCLKReg=NULL;
static UINT16 rxRead, txWritten;
static UINT32 *putBuf, *getBuf;

UINT   GetSpeed(UINT TRAN_SPEED)
{
	double speed,time;
	switch((TRAN_SPEED>>3)&0xF)
	{
		case 0x1:
			time = 1;
			break;
		case 0x2:
			time = 1.2;
			break;
		case 0x3:
			time = 1.3;
			break;
		case 0x4:
			time = 1.5;
			break;
		case 0x5:
			time = 2.0;
			break;
		case 0x6:
			time = 2.5;
			break;
		case 0x7:
			time = 3.0;
			break;
		case 0x8:
			time = 3.5;
			break;
		case 0x9:
			time = 4.0;
			break;
		case 0xA:
			time = 4.5;
			break;
		case 0xB:
			time = 5.0;
			break;
		case 0xC:
			time = 5.5;
			break;
		case 0xD:
			time = 6.0;
			break;
		case 0xE:
			time = 7.0;
			break;
		case 0xF:
			time = 8.0;
			break;
	}
	switch(TRAN_SPEED & 0x7)
	{
	case 0x0:
		speed = 1;
		break;
	case 0x1:
		speed = 10;
		break;
	case 0x2:
		speed = 100;
		 break;
	case 0x3:
		speed = 1000;
		break;
	default:
		speed = 0;
	}
	return (UINT)(speed/time/10);


}
static void pc5000_init_sd()
{
	v_pGPIOReg = (XLLP_GPIO_T *) OALPAtoVA(BULVERDE_BASE_REG_PA_GPIO, FALSE);
	v_pMMCReg  = (XLLP_MMC_T *) OALPAtoVA(BULVERDE_BASE_REG_PA_MMC, FALSE);
	v_pCLKReg  = (P_XLLP_CLKMGR_T ) OALPAtoVA(BULVERDE_BASE_REG_PA_CLKMGR, FALSE);
	
}	
static UINT32 parseResponse( UINT16 * response, BOOL wrap)
{
	UINT32 tempResponse=0;
	if(wrap)  
		tempResponse  =  ((((UINT32)response[2] & 0xff)<< 24) | 
		((UINT32)response[1] << 8) | (response[0] & 0xff00) >> 8 );
	else
		tempResponse  =  ((((UINT32)response[1] & 0xff)<< 24) | 
		((UINT32)response[0] << 8) | (response[2] & 0xff00) >> 8 );		
	
	
	return(tempResponse);
}

static UINT32 checkStatus(P_XLLP_MMC_T mmcReg, UINT32 response)
{
	UINT32 StatusReceived=0;	 
	
	StatusReceived |= ( (response & MMCSD_CARD_STATUS_CS)<<19);
	
	if(mmcReg->MMC_STAT & XLLP_STAT_TORD)
		StatusReceived |= MMCSD_STAT_TOR;
	  	
	if(mmcReg->MMC_STAT & XLLP_STAT_TORSPNS)
		StatusReceived |= MMCSD_STAT_TORSPN;
	
	if(mmcReg->MMC_STAT & XLLP_STAT_CRCWRERR)
		StatusReceived |= MMCSD_STAT_CRCWRER;
	  	
	if(mmcReg->MMC_STAT & XLLP_STAT_CRCRDERR)
		StatusReceived |= MMCSD_STAT_CRCRDERR;
	
	if(mmcReg->MMC_STAT & XLLP_STAT_DATAERRTKN)
		StatusReceived |= MMCSD_STAT_DATAERRTKN;
	  	
	if(mmcReg->MMC_STAT & XLLP_STAT_FLASHERR)
		StatusReceived |= MMCSD_STAT_FLASHERR;
	
	if(response & MMCSD_CARD_STATUS_OOR)
		StatusReceived |= MMCSD_STAT_OUT_OF_RANGE;
	
	if(response & MMCSD_CARD_STATUS_AE)
		StatusReceived |= MMCSD_STAT_ADDRESS_ERR;
	
	if(response & MMCSD_CARD_STATUS_EP )
		StatusReceived |= MMCSD_STAT_ERASE_PARAM;
	  	
	if(response & MMCSD_CARD_STATUS_WPV)
		StatusReceived |= MMCSD_CARD_STATUS_WPV;
	
	if(response & MMCSD_CARD_STATUS_CL)
		StatusReceived |= MMCSD_STAT_CARD_LOCKED;
	  	
	if(response & MMCSD_CARD_STATUS_ERR)
		StatusReceived |= MMCSD_STAT_ADDRESS_ERR;
	return(StatusReceived);	  	
	 	  	
	
}
static void pc5000_init_sd_hardware()
{
	if((v_pGPIOReg==NULL)||(v_pMMCReg==NULL)||(v_pCLKReg==NULL))
		pc5000_init_sd();
	XllpMmcSdHWInit(v_pGPIOReg,v_pCLKReg);//init hardware
	msWait(100);//wait
	//XllpMmcSetUpClock(v_pMMCReg,XLLP_MMC_304KHz, 0);
	XllpMmcSetUpClock(v_pMMCReg,XLLP_MMC_19_5MHz, 0);
    v_pMMCReg->MMC_STRPCL=XLLP_STRPCL_STRTCLK;
}






static STATRES mmcProcessCmd(P_XLLP_MMC_T mmcReg,  mmcStack *MMC)
{
	STATRES statusRes;
	UINT16  res[8];
//	UINT32 *pBuf = databuf;
//	BYTE *psBuf =(BYTE*)databuf;

	XllpMmcSdInts(mmcReg,XLLP_MMC_I_MASK_ENDCMDRES); //bit2
	if (MMC->DATATRANS)    //read or write
	{
		// XllpMmcSdSetupCmd(mmcReg, MMC->CMD, MMC->ADDR, 64,0); 
		goto ExpectedDataTrans;
	}
	else                 //dnone
	{
		XllpMmcSdSetupCmd(mmcReg, MMC->CMD, MMC->ADDR, 64,0);
		//EdbgOutputDebugString("while (!(mmcReg->MMC_STAT & XLLP_STAT_ENDCMDRES))\r\n");
		while (!(mmcReg->MMC_STAT & XLLP_STAT_ENDCMDRES));      //wait intrupt ENDCMDRES
		//EdbgOutputDebugString("while (!(mmcReg->MMC_STAT & XLLP_STAT_ENDCMDRES))\r\n");	
		if(mmcReg->MMC_CMDAT & XLLP_MMC_CMDAT_RESTYPE)    //mmc and spi R3 format        
			goto ExtractResponse;
		else
			goto end;
	}
	
ExpectedDataTrans:
//	EdbgOutputDebugString("ExpectedDataTrans\r\n");
	
	XllpMmcSdSetupXCmd(mmcReg, MMC->FSIZE, MMC->BSIZE , 0xffff);//set NUMBLK=FSIZE/BSIZE and BLKLEN
	XllpMmcSdSetupCmd(mmcReg, MMC->CMD, MMC->ADDR, 64,0); 
//	EdbgOutputDebugString("XllpMmcSdSetupCmd(mmcReg, MMC->CMD, MMC->ADDR, 64,0)\r\n");
	if (MMC->DATATRANS == WRITE)
	{
		XllpMmcSdInts(mmcReg, XLLP_MMC_I_MASK_TXFIFOWRREQ);
	}
	else
	{
		XllpMmcSdInts(mmcReg, XLLP_MMC_I_MASK_RXFIFORDREQ);//set rxfifo int
		
		
	}