/**************************************************************************************
//------------------ MMC/SD-Card Reading and Writing implementation -------------------
//FileName : mmc.c
//Function : Connect AVR to MMC/SD
//Created by : ZhengYanbo
//Created date : 15/08/2005
//Version : V1.2
//Last Modified: 19/08/2005
//Filesystem : Read or Write MMC without any filesystem
//CopyRight (c) 2005 ZhengYanbo
//Email: Datazyb_007@163.com
****************************************************************************************/
#include <avr/io.h>
#include "mmc.h"
#if USE_MMC
//****************************************************************************
// Port Init
void MMC_Port_Init(void)
//****************************************************************************
{
//Config ports
cbi(MMC_Direction_REG,SPI_DI); //Set Pin MMC_DI as Input
sbi(MMC_Direction_REG,SPI_Clock); //Set Pin MMC_Clock as Output
sbi(MMC_Direction_REG,SPI_DO); //Set Pin MMC_DO as Output
sbi(MMC_Direction_REG,MMC_Chip_Select); //Set Pin MMC_Chip_Select as Output
//busy led port init
sbi(MMC_Direction_REG,SPI_BUSY); //Set spi busy led port output
sbi(MMC_Write,SPI_BUSY); //busy led off
sbi(MMC_Write,MMC_Chip_Select); //Set MMC_Chip_Select to High,MMC/SD Invalid.
}
//****************************************************************************
//Routine for Init MMC/SD card(SPI-MODE)
unsigned char MMC_Init(void)
//****************************************************************************
{
unsigned char retry,temp;
unsigned char i;
unsigned char CMD[] = {0x40,0x00,0x00,0x00,0x00,0x95};
//MMC_Port_Init(); //Init SPI port
for(i=0;i<200;i++) //Wait MMC/SD ready...
{
asm("nop");
}
Init_Flag=1; //Set the init flag
for (i=0;i<0x0f;i++)
{
Write_Byte_MMC(0xff); //send 74 clock at least!!!
}
//Send Command CMD0 to MMC/SD Card
retry=0;
do
{ //retry 200 times to send CMD0 command
temp=Write_Command_MMC(CMD);
retry++;
if(retry==200)
{ //time out
return(INIT_CMD0_ERROR);//CMD0 Error!
}
}
while(temp!=1);
//Send Command CMD1 to MMC/SD-Card
CMD[0] = 0x41; //Command 1
CMD[5] = 0xFF;
retry=0;
do
{ //retry 100 times to send CMD1 command
temp=Write_Command_MMC(CMD);
retry++;
if(retry==100)
{ //time out
return(INIT_CMD1_ERROR);//CMD1 Error!
}
}
while(temp!=0);
Init_Flag=0; //Init is completed,clear the flag
MMC_Disable(); //set MMC_Chip_Select to high
return(0); //All commands have been taken.
}
//****************************************************************************
//returns the :
// size of the card in MB ( ret * 1024^2) == bytes
// sector count and multiplier MB are in u08 == C_SIZE / (2^(9-C_SIZE_MULT))
// name of the media
void MMC_get_volume_info(void)
//****************************************************************************
{
//unsigned char i;
VOLUME_INFO_TYPE MMC_volume_Info,*vinf;
vinf=&MMC_volume_Info; //Init the pointoer;
// read the CSD register
Read_CSD_MMC(sectorBuffer.data);
// get the C_SIZE value. bits [73:62] of data
// [73:72] == sectorBuffer.data[6] && 0x03
// [71:64] == sectorBuffer.data[7]
// [63:62] == sectorBuffer.data[8] && 0xc0
vinf->sector_count = sectorBuffer.data[6] & 0x03;
vinf->sector_count <<= 8;
vinf->sector_count += sectorBuffer.data[7];
vinf->sector_count <<= 2;
vinf->sector_count += (sectorBuffer.data[8] & 0xc0) >> 6;
// get the val for C_SIZE_MULT. bits [49:47] of sectorBuffer.data
// [49:48] == sectorBuffer.data[5] && 0x03
// [47] == sectorBuffer.data[4] && 0x80
vinf->sector_multiply = sectorBuffer.data[9] & 0x03;
vinf->sector_multiply <<= 1;
vinf->sector_multiply += (sectorBuffer.data[10] & 0x80) >> 7;
// work out the MBs
// mega bytes in u08 == C_SIZE / (2^(9-C_SIZE_MULT))
vinf->size_MB = vinf->sector_count >> (9-vinf->sector_multiply);
// get the name of the card
Read_CID_MMC(sectorBuffer.data);
vinf->name[0] = sectorBuffer.data[3];
vinf->name[1] = sectorBuffer.data[4];
vinf->name[2] = sectorBuffer.data[5];
vinf->name[3] = sectorBuffer.data[6];
vinf->name[4] = sectorBuffer.data[7];
vinf->name[5] = 0x00; //end flag
/*----------------------------------------------------------
LCDclrscr();
//Print Product name on lcd
i=0;
writestring("Product:");
while((vinf->name[i]!=0x00)&&(i<16)) writechar(vinf->name[i++]);
//Print Card Size(eg:128MB)
gotoxy(1,0);
writestring("Tot:");
writeNumber(vinf->size_MB); writestring("MB ");
//gotoxy(2,0);
//writestring("sector_mult:"); writeNumber(vinf->sector_multiply);
//gotoxy(3,0);
//writestring("sect_cnt:"); writeNumber(vinf->sector_count);*/
}
//****************************************************************************
//Send a Command to MMC/SD-Card
//Return: the second byte of response register of MMC/SD-Card
unsigned char Write_Command_MMC(unsigned char *CMD)
//****************************************************************************
{
unsigned char tmp;
unsigned char retry=0;
unsigned char i;
//set MMC_Chip_Select to high (MMC/SD-Card disable)
MMC_Disable();
//send 8 Clock Impulse
Write_Byte_MMC(0xFF);
//set MMC_Chip_Select to low (MMC/SD-Card active)
MMC_Enable();
//send 6 Byte Command to MMC/SD-Card
for (i=0;i<0x06;i++)
{
Write_Byte_MMC(*CMD++);
}
//get 16 bit response
Read_Byte_MMC(); //read the first byte,ignore it.
do
{ //Only last 8 bit is used here.Read it out.
tmp = Read_Byte_MMC();
retry++;
}
while((tmp==0xff)&&(retry<100));
return(tmp);
}
//****************************************************************************
//Routine for reading a byte from MMC/SD-Card
unsigned char Read_Byte_MMC(void)
//****************************************************************************
{
unsigned char temp=0;
unsigned char i;
cbi(MMC_Write,SPI_BUSY); //MMC_BUSY_LED=0;
//Software SPI
for (i=0; i<8; i++) //MSB First
{
cbi(MMC_Write,SPI_Clock); //Clock Impuls (Low)
if(Init_Flag) delay_us_8_;
//read mmc data out pin
if((MMC_Read&(1<<SPI_DI))!=0)
temp = (temp << 1) + 1;
else
temp = (temp << 1) + 0;
sbi(MMC_Write,SPI_Clock); //set Clock Impuls High
if(Init_Flag) delay_us_8_;
}
sbi(MMC_Write,SPI_BUSY); //MMC_BUSY_LED=1;
return (temp);
}
//****************************************************************************
//Routine for sending a byte to MMC/SD-Card
void Write_Byte_MMC(unsigned char value)
//****************************************************************************
{
unsigned char i;
cbi(MMC_Write,SPI_BUSY); //MMC_BUSY_LED=0;
//Software SPI
for (i=0; i<8; i++)
{ //write a byte
if (((value >> (7-i)) & 0x01)==0x01)
sbi(MMC_Write,SPI_DO); //Send bit by bit(MSB First)
else
cbi(MMC_Write,SPI_DO);
cbi(MMC_Write,SPI_Clock); //set Clock Impuls low
if(Init_Flag) delay_us_8_;
sbi(MMC_Write,SPI_Clock); //set Clock Impuls High
if(Init_Flag) delay_us_8_;
}//write a byte
sbi(MMC_Write,SPI_DO); //set Output High
sbi(MMC_Write,SPI_BUSY); //MMC_BUSY_LED=1;
}
//****************************************************************************
//Routine for writing a Block(512Byte) to MMC/SD-Card
//Return 0 if sector writing is completed.
unsigned char MMC_write_sector(unsigned long addr,unsigned char *Buffer)
//****************************************************************************
{
unsigned char tmp,
