mmc_sd.c

MP3源码 内有SD2.0 驱动 FAT32 驱动

/*******************************************************************/
/*          SD diriver for  MP3 Player                             */
/*                                                                 */
/* Platform   : AVRStudio4.13 b528 + WinAVR20070525                */
/*              optimize -0s                                       */
/* Author     : bozai(Zhang Qibo)                                  */
/* E-mail     : [e-mail]                                    */
/* MSN        : [e-mail]                         */
/* Date       : 2006-06-16                                         */
/*******************************************************************/
/*  2007-10-21: Rewrite some function, now only suply 4 functions  */
/*  2007-10-18: Adjust some time & retry count for compatibility   */
/*              consideration                                      */
/*  2007-06-16: After reading the spec. in detail, I found some    */
/*              of the code don't meet the spec., that is after    */
/*              the last SPI transaction, it need an extra 8 CLK   */
/*              to finish it's work                                */
/*  2007-05-04: add read capacity function                         */
/*  2007-04-21:                                                    */
/*  Enable some code incase that when SD reset                     */
/*  faild program can't jump the loop                              */
/*******************************************************************/

#include <avr/io.h>
#include "MMC_SD.h"

#define BYTE_MODE   0
#define BLOCK_MODE 1

static uint8 address_mode=BYTE_MODE;


/* spi low speed, below 400KHz */
void SPI_Low(void)
{
	SPCR =   _BV(SPE)|_BV(MSTR)|_BV(SPR1)|_BV(SPR0);
	SPSR &= ~_BV(SPI2X);
}

/* spi high speed, not exceed 25MHz */
void SPI_High(void)
{
	SPCR =  _BV(SPE)|_BV(MSTR);
	SPSR |= _BV(SPI2X);
}


/* read and write one byte , full duplex */
uint8 SPI_WriteByte(uint8 val)
{
	SPDR = val;
	while(!(SPSR & _BV(SPIF)));
	return SPDR;
}

/* sd send command */ 
uint8 MMC_SD_SendCommand(uint8 cmd, uint32 arg)
{
	uint8 r1;
	uint8 retry=0;
	
	SPI_WriteByte(0xff);
	SPI_CS_Assert;
	
	SPI_WriteByte(cmd | 0x40);	/* send command */
	SPI_WriteByte(arg>>24);
	SPI_WriteByte(arg>>16);
	SPI_WriteByte(arg>>8);
	SPI_WriteByte(arg);
	SPI_WriteByte(0x95);
	
	while((r1 = SPI_WriteByte(0xff)) == 0xff)	/* wait response */
		if(retry++ > 0xfe) break;				/* time out error */

	SPI_CS_Deassert;
	SPI_WriteByte(0xff);				// extra 8 CLK

	return r1;								/* return state */
}

/* sd send command */ 
uint8 MMC_SD_SendCommandCRC(uint8 cmd, uint32 arg, uint8 crc)
{
	uint8 r1;
	uint8 retry=0;
	
	SPI_WriteByte(0xff);
	SPI_CS_Assert;
	
	SPI_WriteByte(cmd | 0x40);	/* send command */
	SPI_WriteByte(arg>>24);
	SPI_WriteByte(arg>>16);
	SPI_WriteByte(arg>>8);
	SPI_WriteByte(arg);
	SPI_WriteByte(crc);
	
	while((r1 = SPI_WriteByte(0xff)) == 0xff)	/* wait response */
		if(retry++ > 0xfe) break;				/* time out error */

	SPI_CS_Deassert;
	SPI_WriteByte(0xff);				// extra 8 CLK

	return r1;								/* return state */
}


/* sd send command */ 
uint8 MMC_SD_SendCommandCRC_NoDeassert(uint8 cmd, uint32 arg, uint8 crc)
{
	uint8 r1;
	uint8 retry=0;
	
	SPI_WriteByte(0xff);
	SPI_CS_Assert;
	
	SPI_WriteByte(cmd | 0x40);	/* send command */
	SPI_WriteByte(arg>>24);
	SPI_WriteByte(arg>>16);
	SPI_WriteByte(arg>>8);
	SPI_WriteByte(arg);
	SPI_WriteByte(crc);
	
	while((r1 = SPI_WriteByte(0xff)) == 0xff)	/* wait response */
		if(retry++ > 0xfe) break;				/* time out error */

	return r1;								/* return state */
}

#if 1
#include<avr/pgmspace.h>
#include<stdio.h>
#include<avr/delay.h>
#endif

/* SD card initialization, include reset and configuration */
uint8 MMC_SD_Init(void)
{
	uint8 i;
	uint8 retry = 0;
	uint8 r1 = 0;

	uint16 j;

	uint8 buffer[4];
	
	MMC_SD_PORT_INI;	/* Port Initialize */
	SPI_Low();			/* SPI intialize */
	
	do
	{
		for(i=0;i<10;i++) SPI_WriteByte(0xff);
		r1 = MMC_SD_SendCommandCRC(0, 0, 0x95);/*send idle command*/
		retry++;
		if(retry>0xfe) return 1;/*time out*/
	} while(r1 != 0x01);	

	
	r1 = MMC_SD_SendCommandCRC_NoDeassert(8, 0x1aa, 0x87);/*check version*/
	
	if(r1 == 0x05) /*version 1*/  /*if it is version 2, then it will return invalid command, that is bit 2*/
	{
		
		SPI_CS_Deassert;
		SPI_WriteByte(0xff);				/* extra 8 CLK */
		
		printf_P(PSTR("\r\nVersion 1"));

		retry = 0;
		do
		{
			r1 = MMC_SD_SendCommandCRC(55, 0, 0);
			if(r1!=0x01)
			{
				//printf_P(PSTR("\r\n CMD55 r1=%x "),r1);
				return r1;
			}
			retry ++;
			r1 = MMC_SD_SendCommandCRC(41, 0, 0);

		}while((r1!=0)&&(retry<200));

		if (retry==200) /*then it should be MMC card:   note: not tested! */
		{
			retry = 0;
			do
			{
				r1 = MMC_SD_SendCommand(1, 0);/*send active command*/
				retry++;
				if(retry>0xfe) return 1;/*time out*/
			} while(r1);
		}
		
		SPI_High();		/* Use High Speed SPI*/
		
		r1 = MMC_SD_SendCommand(59, 0);/*disable CRC*/	
		if(r1 != 0)return r1;
		
		r1 = MMC_SD_SendCommand(16, 512);/*set sector size to 512*/
		if(r1 != 0)return r1;

		address_mode = BYTE_MODE;
	}
	
	else if(r1 == 0x01)/*version 2*/  /*it only return idle*/
	{
		for(i=0;i<3;i++){buffer[i]=SPI_WriteByte(0xff);printf("%x ",buffer[i]);}
		//if(buffer[2]!=0xaa || ((buffer[1]&0xf)!=0x01))
		//{
		//	printf_P(PSTR("\r\n pattern error"));
		//	goto exit1;
		//}

		SPI_CS_Deassert;
		SPI_WriteByte(0xff);				/* extra 8 CLK */

		printf_P(PSTR("\r\nVersion 2"));

		retry = 0;
		do
		{
			r1 = MMC_SD_SendCommandCRC(55, 0, 0);
			if(r1!=0x01)
			{
				//printf_P(PSTR("\r\n CMD55 r1=%x "),r1);
				return r1;
			}

			r1 = MMC_SD_SendCommandCRC(41, 0x40000000, 0);

		}while(r1!=0);

		if(MMC_SD_SendCommandCRC_NoDeassert(58, 0, 0)!=0x00)goto exit1; /*read OCR*/
		for(i=0;i<4;i++)buffer[i]=SPI_WriteByte(0xff);

		if(buffer[0]&(1<<6))
			address_mode = BLOCK_MODE;
		else
			address_mode = BYTE_MODE;
		
		SPI_CS_Deassert;
		SPI_WriteByte(0xff);				/* extra 8 CLK */


		SPI_High();		/* Use High Speed SPI*/

	}
	else
	{
		//printf_P(PSTR("\r\nnot supported card"));
	}


	printf_P(PSTR("\r\naddress mode = %d"),address_mode);


	return 0; /*normal return*/
	exit1:
		//printf_P(PSTR("\r\nexit 1  r1=%x "),r1);

		SPI_CS_Deassert;
		SPI_WriteByte(0xff);				/* extra 8 CLK */
		return 1;	
}



//读一个扇区		//read one sector
uint8 MMC_SD_ReadSingleBlock(uint32 sector, uint8* buffer)
{
	uint8 r1;
	uint16 i;
	uint16 retry=0;

	SPI_High();		/* Use High Speed SPI*/

	r1 = MMC_SD_SendCommand(17, address_mode?sector:sector<<9);//读命令	//read command
	
	if(r1 != 0x00)
		return r1;

	SPI_CS_Assert;
	//等数据的开始	//wait to start recieve data
	while(SPI_WriteByte(0xff) != 0xfe)if(retry++ > 0xfffe){SPI_CS_Deassert;return 1;}

	for(i=0; i<512; i++)//读512个数据	//read 512 bytes
	{
		*buffer++ = SPI_WriteByte(0xff);
	}

	SPI_WriteByte(0xff);//伪crc    //dummy crc
	SPI_WriteByte(0xff);
	
	SPI_CS_Deassert;
	SPI_WriteByte(0xff);// extra 8 CLK

	return 0;
}


//写一个扇区		//wirite one sector //not used in this application
uint8 MMC_SD_WriteSingleBlock(uint32 sector, uint8* buffer)
{
	uint8 r1;
	uint16 i;
	uint16 retry=0;
	
	SPI_High();		/* Use High Speed SPI*/

	r1 = MMC_SD_SendCommand(24,  address_mode?sector:sector<<9);//写命令	//send command
	if(r1 != 0x00)
		return r1;

	SPI_CS_Assert;
	
	SPI_WriteByte(0xff);
	SPI_WriteByte(0xff);
	SPI_WriteByte(0xff);

	SPI_WriteByte(0xfe);//发开始符			//send start byte "token"
	
	for(i=0; i<512; i++)//送512字节数据		//send 512 bytes data
	{
		SPI_WriteByte(*buffer++);
	}
	
	SPI_WriteByte(0xff);			//dummy crc
	SPI_WriteByte(0xff);
	
	r1 = SPI_WriteByte(0xff);
	
	if( (r1&0x1f) != 0x05)//等待是否成功	//judge if it successful
	{
		SPI_CS_Deassert;
		return r1;
	}
	//等待操作完		//wait no busy
	while(!SPI_WriteByte(0xff))if(retry++ > 0xfffe){SPI_CS_Deassert;return 1;}

	SPI_CS_Deassert;
	SPI_WriteByte(0xff);// extra 8 CLK

	return 0;
}


/* return number of max block, in case of 512bytes per unit */
uint32 MMC_SD_ReadCapacity()
{
	uint8 r1;
	uint16 i;
	uint16 temp;
	uint8 buffer[16];
	uint32 Capacity;
	uint32 retry =0;
	//uint8 retry=0;

	//if(address_mode==BLOCK_MODE) return 0; /*currently I do not have the spec. so do not kown how to calculate the capacity*/
	
	SPI_High();		/* Use High Speed SPI*/

	r1 = MMC_SD_SendCommand(9, 0);//写命令	//send command  //READ CSD
	if(r1 != 0x00)
		return r1;

	SPI_CS_Assert;
	while(SPI_WriteByte(0xff) != 0xfe)if(retry++ > 0x1fffe){SPI_CS_Deassert;return 1;}

	
	for(i=0;i<16;i++)
	{
		buffer[i]=SPI_WriteByte(0xff);
	}	

	SPI_WriteByte(0xff);
	SPI_WriteByte(0xff);
	
	SPI_WriteByte(0xff);
	
	SPI_CS_Deassert;

	SPI_WriteByte(0xff);// extra 8 CLK

	if((buffer[0]&0xc0)==0x40)
	{
		Capacity =  (((uint32)buffer[8])<<8 + (uint32)buffer[9] +1)*(uint32)1024;
		return Capacity;
	}

/*********************************/
//	C_SIZE
	i = buffer[6]&0x03;
	i<<=8;
	i += buffer[7];
	i<<=2;
	i += ((buffer[8]&0xc0)>>6);

/**********************************/
//  C_SIZE_MULT

	r1 = buffer[9]&0x03;
	r1<<=1;
	r1 += ((buffer[10]&0x80)>>7);


/**********************************/
// BLOCKNR

	r1+=2;

	temp = 1;
	while(r1)
	{
		temp*=2;
		r1--;
	}
	
	Capacity = ((uint32)(i+1))*((uint32)temp);

/////////////////////////
// READ_BL_LEN

	i = buffer[5]&0x0f;

/*************************/
//BLOCK_LEN

	temp = 1;
	while(i)
	{
		temp*=2;
		i--;
	}
/************************/


/************** formula of the capacity ******************/
//
//  memory capacity = BLOCKNR * BLOCK_LEN
//	
//	BLOCKNR = (C_SIZE + 1)* MULT
//
//           C_SIZE_MULT+2
//	MULT = 2
//
//               READ_BL_LEN
//	BLOCK_LEN = 2
/**********************************************/

//The final result
	
	Capacity *= (uint32)temp;	 
	return Capacity/512;		
}