/**************************************************************************************
//------------------ MMC/SD-Card Reading and Writing implementation -------------------
//FileName     : mmc.c
//Function     : Connect STC51 to MMC/SD 
//Created by   : ZHENNAN.YU
//Created date : 10/12/2007
//Version      : V1.2
//Last Modified: 19/08/2005
//Filesystem   : Read or Write MMC without any filesystem

//CopyRight (c) 2007 ZHENNAN.YU
//Email: yzn07@yahoo.com.cn
****************************************************************************************/
sbit SPI_DI =P1^1;
sbit SPI_DO =P1^3;
sbit SPI_SCL=P1^2;
sbit SPI_CS =P1^0;
sbit SPI_BY =P1^4;

//------------------------------------------------------------
// Error define
//-------------------------------------------------------------
#define INIT_CMD0_ERROR     0x01
#define INIT_CMD1_ERROR		0x02
#define WRITE_BLOCK_ERROR	0x03
#define READ_BLOCK_ERROR   	0x04 
//-------------------------------------------------------------

// data type
//-------------------------------------------------------------   
// this structure holds info on the MMC card currently inserted 

typedef struct MMC_VOLUME_INFO
{ //MMC/SD Card info
  unsigned int  size_MB;
  unsigned char sector_multiply;
  unsigned int  sector_count;
  unsigned char name[6];
} VOLUME_INFO_TYPE; 

typedef struct STORE 
{ 
  unsigned char dat[100]; 
} BUFFER_TYPE; //256 bytes, 128 words

BUFFER_TYPE sectorBuffer; //512 bytes for sector buffer

//--------------------------------------------------------------
unsigned int  readPos=0;
unsigned char sectorPos=0;
unsigned char LBA_Opened=0; //Set to 1 when a sector is opened.
unsigned char Init_Flag;    //Set it to 1 when Init is processing.
//---------------------------------------------------------------

void delay(unsigned int time)
{
 while(time--);
}

//****************************************************************************
// Port Init
void MMC_Port_Init()
//****************************************************************************
{
   SPI_SCL=1;
   SPI_DO =1;
   SPI_CS=1;
   send_s("Port Init!");
/*
   //Config ports 
   SPI_DI=1;          //Set Pin MMC_DI as Input
   SPI_SCL=1;         //Set Pin MMC_Clock as Output
   SPI_DO=1;          //Set Pin MMC_DO as Output
   SPI_CS=1;          //Set MMC_Chip_Select to High,MMC/SD Invalid.
   //busy led port init
   //SPI_BY=1;        //Set spi busy led port output
   //MMC_BUSY_LED=1;                      //busy led off     
   */               
}

//****************************************************************************
//Routine for sending a byte to MMC/SD-Card
void Write_Byte_MMC(unsigned char value)
//****************************************************************************
{ 
   unsigned char i; 
   
   SPI_BY=0; 
   //Software SPI
   for (i=0;i<8;i++) 
   {  //write a byte
      if (((value>>(7-i))&0x01)==0x01) 
	   SPI_DI=1; //Send bit by bit(MSB First)
      else SPI_DI=0;
       SPI_SCL=0; //set Clock Impuls low
      if(Init_Flag) 
	   delay(8); 
      SPI_SCL=1; //set Clock Impuls High
      if(Init_Flag) 
	   delay(8);     
   }//write a byte
   //MMC_BUSY_LED=1;
}

//****************************************************************************
//Routine for reading a byte from MMC/SD-Card
unsigned char Read_Byte_MMC()
//****************************************************************************
{ 
   unsigned char temp=0;
   unsigned char i;

   SPI_BY=0;
   //Software SPI
   for (i=0;i<8;i++) //MSB First
   {
      SPI_DO=1;
      SPI_SCL=0; //Clock Impuls (Low)
      if(Init_Flag)
	   delay(8);
      temp=(temp<<1)+(unsigned char)SPI_DO; //read mmc data out pin 
      SPI_SCL=1; //set Clock Impuls High
      if(Init_Flag) 
	   delay(8);	
   }
   SPI_BY=1;
   return (temp);
}

//****************************************************************************
//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) 
   SPI_CS=1;
   //send 8 Clock Impulse
   Write_Byte_MMC(0xFF);
   //set MMC_Chip_Select to low (MMC/SD-Card active)
   SPI_CS=0;

   //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 Init MMC/SD card(SPI-MODE)
unsigned char MMC_Init()
//****************************************************************************
{  
   unsigned char retry,temp;
   unsigned char i;
   unsigned char CMD[] = {0x40,0x00,0x00,0x00,0x00,0x95};
   send_s("SD CARD Init!");
   MMC_Port_Init(); //Init SPI port  

   delay(200);
   
   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
   send_s("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
   send_s("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 
   
   SPI_CS=1;  //set MMC_Chip_Select to high 
   send_s("SD CARD Init Suc!!");
   return(0x55); //All commands have been taken.
} 

//****************************************************************************
//Routine for reading data Registers of MMC/SD-Card
//Return 0 if no Error.
unsigned char MMC_Read_Block(unsigned char *CMD,unsigned char *Buffer,unsigned int Bytes)
//****************************************************************************
{  
   unsigned int i; 
   unsigned retry,temp;
    
   //Send Command CMD to MMC/SD-Card
   retry=0;
   do
   {  //Retry 100 times to send command.
      temp=Write_Command_MMC(CMD);
      retry++;
      if(retry==100) 
      {
        return(READ_BLOCK_ERROR); //block write Error!
      }
   }
   while(temp!=0); 
   			
   //Read Start Byte form MMC/SD-Card (FEh/Start Byte)
   while (Read_Byte_MMC()!=0xfe);
	
   //Write blocks(normal 512Bytes) to MMC/SD-Card
   for (i=0;i<Bytes;i++)
   {
      *Buffer++ = Read_Byte_MMC();
   }
   
   //CRC-Byte
   Read_Byte_MMC();//CRC - Byte 
   Read_Byte_MMC();//CRC - Byte
	
   //set MMC_Chip_Select to high (MMC/SD-Card invalid)
   SPI_CS=1;
   return(0);
}

//***************************************************************************
//Routine for reading CSD Registers from MMC/SD-Card (16Bytes)
//Return 0 if no Error.
unsigned char Read_CSD_MMC(unsigned char *Buffer)
//***************************************************************************
{