main_save2.c

基于U（375）盘及SD（SPI模式）卡集成文件系统（包括底层驱动）

DSTATUS MMC_Init()
{
	unsigned char retry,temp;
	unsigned char temp1[100];
    unsigned char i;
    unsigned int j;
    unsigned char ty;
    unsigned char ocr[4];
    unsigned char cmd;
    if(Stat & STA_NODISK) return Stat;
    for (i=0;i<20;i++)
    {
    	temp = SPI_TransferByte(0xff); //send 74 clock at least!!!
    }
    //复位为idle 
    if(Write_Command_MMC(CMD0,0)==0x01)
    {
    	Timer1 = 100;
    	if(Write_Command_MMC(CMD8,0x1AA) ==0x01)
    	{
    		for(i=0;i<4;i++)
    			ocr[i] = SPI_TransferByte(0xff);
    		if(ocr[2] == 0x01 && ocr[3] == 0xAA){
    			while(Timer1 && Write_Command_MMC(ACMD41 , 1UL <<30));
    			if(Timer1 && Write_Command_MMC(CMD58, 0) ==0){
    				for(i=0;i<4;i++) ocr[i] = SPI_TransferByte(0xff);
    				ty = (ocr[0] & 0x40)? 12: 4;
    			}
    		}
    	}
    	else
    	{
    		if(Write_Command_MMC(ACMD41, 0)<=1)
    		{
    			ty = 2; cmd = ACMD41;
    		}
    		else
    		{
    			ty = 1;
    			cmd = CMD1;
    		}
    		while(Timer1 && Write_Command_MMC(cmd,0));
    		if(!Timer1 || Write_Command_MMC(CMD16, 512) !=0)
    			ty = 0;
    	}
    }
    CardType = ty;
    if(ty)
    {
    	Stat = STA_INITED;
    }
    else
    	Stat = STA_NOINIT;
    return Stat;
    	
}

DSTATUS disk_status()
{
	return Stat;
}

void MMC_HardwareInitial()
{
	return;
}


DRESULT MMC_read_sector(unsigned int addr,unsigned char count, unsigned char *buff)
{
	if(!count) return RES_PARERR;
	if(Stat == STA_NOINIT) return RES_NOTRDY;
	if(!(CardType&8)) addr = addr*512;
	SPI_TransferByte(0xff);
	if(count ==1)
	{
		if((Write_Command_MMC(CMD17,addr)<=1)&&rcvr_datablock(buff,512))
			count = 0;
	}
	else
	{
		if(Write_Command_MMC(CMD18,addr)==0)
		{
			do{
				if(!rcvr_datablock(buff, 512)) 
					break;
				buff =buff + 512;
			}while(--count);
			Write_Command_MMC(CMD12,0);
		}
	}
	SPI_TransferByte(0xff);
	return count ? RES_ERROR : RES_OK;
}

DRESULT MMC_write_sector(unsigned int addr, unsigned char count, unsigned char *buff)
{
	unsigned char temp;
	unsigned short write_wait = 65535;
	if(!count) return RES_PARERR;
	if(Stat == STA_NOINIT) return RES_NOTRDY;
	if(Stat == STA_PROTECT) return RES_WRPRT;
	
	if(!(CardType & 8)) addr = addr * 512;
	SPI_TransferByte(0xff);
	SPI_TransferByte(0xff);  //wait at least 8 clock
	if(count == 1)
	{
		if(Write_Command_MMC(CMD24, addr)==0x00)
		{
			if(xmit_datablock(buff,0xFE))
				count = 0;
			write_wait = 65535;
			do{
				temp = SPI_TransferByte(0xff);
				write_wait--;
			}while((temp!=0xff)&&write_wait);    //wait for write complete
			if(!write_wait)	return RES_ERROR;
		}
				
	}
	else
	{
		if(CardType == 6) 
			Write_Command_MMC(ACMD23, count);
		if(Write_Command_MMC(CMD25,addr)==0x00)
		{
			do{
				if(!xmit_datablock(buff,0xFC)) break;
					buff = buff +512;
					write_wait = 65535;
					do{
						temp = SPI_TransferByte(0xff);
						write_wait--;
					}while((temp!=0xff)&&write_wait);
					if(!write_wait)	return RES_ERROR;
			}while(--count);
			xmit_datablock(0,0xFD);
			write_wait = 65535;
			do{
				temp = SPI_TransferByte(0xff);
				write_wait--;
			}while((temp!=0xff)&&write_wait);
			if(!write_wait)	return RES_ERROR;
		}
	}

	return count?RES_ERROR:RES_OK;
}

DRESULT disk_ioctl (
	CTRL_CODE ctrl,		/* Control code */
	void *buff		/* Buffer to send/receive control data */
)
{
	DRESULT res;
	unsigned char n, csd[16], *ptr = buff;
	unsigned int csize;
	
	if (Stat == STA_NOINIT) return RES_NOTRDY;

	res = RES_ERROR;
	switch (ctrl) {
		case CTRL_SYNC :		/* Make sure that no pending write process */
			if (SPI_TransferByte(0xff) == 0xFF)
				res = RES_OK;
			break;

		case GET_SECTOR_COUNT :	/* Get number of sectors on the disk (DWORD) */
			if ((Write_Command_MMC(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) {
				if ((csd[0] >> 6) == 1) {	/* SDC ver 2.00 */
					csize = csd[9] + ((WORD)csd[8] << 8) + 1;
					*(unsigned int*)buff = (unsigned int)csize << 10;
				} else {					/* SDC ver 1.XX or MMC */
					n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
					csize = (csd[8] >> 6) + ((WORD)csd[7] << 2) + ((WORD)(csd[6] & 3) << 10) + 1;
					*(unsigned int*)buff = (unsigned int)csize << (n - 9);
				}
				res = RES_OK;
			}
			break;

		case GET_SECTOR_SIZE :	/* Get R/W sector size (WORD) */
			*(unsigned int*)buff = 512;
			res = RES_OK;
			break;

		case GET_BLOCK_SIZE :	/* Get erase block size in unit of sector (DWORD) */
			if (CardType == 4) {			/* SDC ver 2.00 */
				if (Write_Command_MMC(ACMD13, 0) == 0) {		/* Read SD status */
					SPI_TransferByte(0xff);
					if (rcvr_datablock(csd, 16)) {				/* Read partial block */
						for (n = 64 - 16; n; n--) SPI_TransferByte(0xff);	/* Purge trailing data */
						*(unsigned int*)buff = 16UL << (csd[10] >> 4);
						res = RES_OK;
					}
				}
			} else {					/* SDC ver 1.XX or MMC */
				if ((Write_Command_MMC(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) {	/* Read CSD */
					if (CardType == 2) {			/* SDC ver 1.XX */
						*(unsigned int*)buff = (((csd[10] & 63) << 1) + ((unsigned int)(csd[11] & 128) >> 7) + 1) << ((csd[13] >> 6) - 1);
					} else {					/* MMC */
						*(unsigned int*)buff = ((unsigned int)((csd[10] & 124) >> 2) + 1) * (((csd[11] & 3) << 3) + ((csd[11] & 224) >> 5) + 1);
					}
					res = RES_OK;
				}
			}
			break;

		case MMC_GET_TYPE :		/* Get card type flags (1 byte) */
			*ptr = CardType;
			res = RES_OK;
			break;

		case MMC_GET_CSD :		/* Receive CSD as a data block (16 bytes) */
			if (Write_Command_MMC(CMD9, 0) == 0		/* READ_CSD */
				&& rcvr_datablock(ptr, 16))
				res = RES_OK;
			break;

		case MMC_GET_CID :		/* Receive CID as a data block (16 bytes) */
			if (Write_Command_MMC(CMD10, 0) == 0		/* READ_CID */
				&& rcvr_datablock(ptr, 16))
				res = RES_OK;
			break;

		case MMC_GET_OCR :		/* Receive OCR as an R3 resp (4 bytes) */
			if (Write_Command_MMC(CMD58, 0) == 0) {	/* READ_OCR */
				for (n = 4; n; n--) *ptr++ = SPI_TransferByte(0xff);
				res = RES_OK;
			}
			break;

		case MMC_GET_SDSTAT :	/* Receive SD statsu as a data block (64 bytes) */
			if (Write_Command_MMC(ACMD13, 0) == 0) {	/* SD_STATUS */
				SPI_TransferByte(0xff);
				if (rcvr_datablock(ptr, 64))
					res = RES_OK;
			}
			break;

		default:
			res = RES_PARERR;
	}

	release_spi();

	return res;
}

void test_control()
{
	CTRL_CODE ctrl1,ctrl2,ctrl3,ctrl4,ctrl5,ctrl6,ctrl7,ctrl8,ctrl9,ctrl10;
	void* buff1;
	DRESULT ioctl_result;
	buff1 = malloc(64);
	
	ctrl1= CTRL_SYNC;
	ctrl2= GET_SECTOR_COUNT;
	ctrl3 = GET_SECTOR_SIZE;
	ctrl4 = GET_BLOCK_SIZE;
	ctrl5 = MMC_GET_TYPE;
	ctrl6 = MMC_GET_CSD;
	ctrl7 = MMC_GET_CID;
	ctrl8 = MMC_GET_OCR;
	ctrl9 = MMC_GET_SDSTAT;
	
	ioctl_result = disk_ioctl(ctrl1, buff1);
}
	
void SwiMainFunc() {
	unsigned char temp;
	int i;
	
  TIMER_Config MyTimerConfig = {   	0x000002C0, /* ctl */   
  									0xFFFFFFFF, /* prd */   
  									0x00000000  /* cnt */ 
  								};

 
	for(i=0;i<10000;i++)
	{
		buff_w[i]=i;
		buff_r[i]=0;
	}
  /* The following code                                         */
  /* configures the serial port for digital loopback mode. We   */
  /* then use the CPU to write/read from the port. In loopback  */
  /* mode, we should read the same value as written, this is    */
  /* checked for in a loop.                                     */
  
  /* Let's open up serial port 1 */
  myMcbsp = MCBSP_open(MCBSP_DEV0, MCBSP_OPEN_RESET);

  MCBSP_config(myMcbsp , &myInitialConfig );
  /* Now that the port is setup, let's enable it in steps. */

  
  MCBSP_enableSrgr(myMcbsp);
  printf("wait for two clock");
  MCBSP_enableRcv(myMcbsp);
  MCBSP_enableXmt(myMcbsp);

  
  htimer1 = TIMER_open(TIMER_DEVANY,0);
  TIMER_config(htimer1,&MyTimerConfig);
  start = TIMER_getCount(htimer1);
  end = TIMER_getCount(htimer1);    
  overhead = end - start ; 
  
//    MMC_HardwareInitial();
	MMC_Init();
//	MCBSP_config(myMcbsp, &myInitialConfig);
//	MCBSP_enableSrgr(myMcbsp);
  	printf("wait for two clock");
//  	MCBSP_enableRcv(myMcbsp);
//  	MCBSP_enableXmt(myMcbsp);
//	testocr();                       
//	TestReadRegister(address);
//	check_security();
	res_status1 = MMC_write_sector(25,4, buff_w);

	res_status2 = MMC_read_sector(25,4, buff_r);
// 	res_status2 = MMC_write_sector(5,1, buff_w);
  
 	test_control();
  /* All done now, close the port. */
  MCBSP_close(myMcbsp);
  LOG_printf(&LogMain,"<DONE>");
}

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
void main() {

  /* Initialize the chip support library, required */
  CSL_init();
 // SwiMainFunc();
  SWI_post(&SwiMain);
}  

/*----------------------------------------------------------------------------*/
/******************************************************************************\
* End of main.c
\******************************************************************************/