mmc.c

str71x SD MMC卡 读写 文件系统

// mmc.c : MultiMediaCard functions: init, read, write ...
//
// Rolf Freitag 5/2003
//

// MMC Lib
#ifndef _MMCLIB_C
#define _MMCLIB_C
//---------------------------------------------------------------------
#include "mmc.h"
#include <iostr711.h>
#include <inarm.h>
//#include "led.h"

//#include  "MSP430x14x.H"

//#include  "math.h"
#include  "string.h"

char mmcGetResponse(void);
char mmcGetXXResponse(const char resp);
char mmcCheckBusy(void);

void initSPI (void);

char mmc_buffer[512] = { 0 };	// Buffer for mmc i/o for data and registers
extern char card_state;		// 0 for no card found, 1 for card found (init successfull)


//---------------------------------------------------------------------

void Delays (unsigned long a) { while (--a!=0); }


// setup usart1 in spi mode
void initSPI1 (void)
{
//  BSPI0_CSR1_bit.BSPE=1;

  IOPORT0_PC0_bit.no4=1;               //MISO
  IOPORT0_PC1_bit.no4=1;               //
  IOPORT0_PC2_bit.no4=1;               //

  IOPORT0_PC0_bit.no5=1;               //MOSI
  IOPORT0_PC1_bit.no5=1;               //
  IOPORT0_PC2_bit.no5=1;               //

  IOPORT0_PC0_bit.no6=1;               //SCLK
  IOPORT0_PC1_bit.no6=1;               //
  IOPORT0_PC2_bit.no6=1;               //

  IOPORT0_PC0_bit.no7=1;               //SS1 is I/0
  IOPORT0_PC1_bit.no7=0;               //
  IOPORT0_PC2_bit.no7=1;               //

  IOPORT0_PC0_bit.no12=1;               //P0.12 is I/0 MMC_CS
  IOPORT0_PC1_bit.no12=0;               //
  IOPORT0_PC2_bit.no12=1;               //

  IOPORT0_PD_bit.no7=1;               //SS1=1

  BSPI1_CLK=0x00FF;
  BSPI1_CSR1_bit.MSTR=1;
  BSPI1_CSR1_bit.BSPE=1;
//  BSPI1_CSR1=0x0003;
//  BSPI1_CSR2=0x0000;

}
void initSPI0 (void)
{
//  BSPI0_CSR1_bit.BSPE=1;

  PRCCU_BOOTCR |= 0x4;

  IOPORT0_PC0_bit.no0=1;               //MISO
  IOPORT0_PC1_bit.no0=1;               //
  IOPORT0_PC2_bit.no0=1;               //

  IOPORT0_PC0_bit.no1=1;               //MOSI
  IOPORT0_PC1_bit.no1=1;               //
  IOPORT0_PC2_bit.no1=1;               //

  IOPORT0_PC0_bit.no2=1;               //SCLK
  IOPORT0_PC1_bit.no2=1;               //
  IOPORT0_PC2_bit.no2=1;               //

  IOPORT0_PC0_bit.no3=1;               //SS
  IOPORT0_PC1_bit.no3=1;               //
  IOPORT0_PC2_bit.no3=1;               //

  BSPI0_CLK=0x00FF;
//  BSPI0_CSR1_bit.MSTR=1;
//  BSPI0_CSR1_bit.BSPE=1;
  BSPI0_CSR1=0x0003;
  BSPI0_CSR2=0x0000;

}

void spi1WriteByte(unsigned int data1)
{
  while(BSPI1_CSR2_bit.TFE == 0);      // Wait until the character can be sent
//  SSIOINT_bit.TXCMP = 1;            // clear interrupt register
  BSPI1_TXR = data1;
}

void spi0WriteByte(unsigned int data0)
{
  while(BSPI0_CSR2_bit.TFE == 0);      // Wait until the character can be sent
//  SSIOINT_bit.TXCMP = 1;            // clear interrupt register
  BSPI0_TXR = data0;
}
unsigned char spiReadByte()
{
  unsigned char spib;
//  while(SSIOINT_bit.RXCMP == 0);
  if (BSPI1_CSR2_bit.RFNE == 0);
  spib = BSPI1_RXR;                   // Get the data received
// SSIOINT_bit.RXCMP = 1;            //clear interrupt register
  return spib;
}

// Initialisieren
char initMMC (void)
{

   //raise SS and MOSI for 80 clock cycles
  //SendByte(0xff) 10 times with SS high
  //RAISE SS
  int i;
  char response=0x01;


 // debug_printf("Start iniMMC......");
  initSPI1();
  //initialization sequence on PowerUp
  CS_HIGH();              //!!!!!!!!!!!!!!!!!!
  for(i=0;i<=9;i++)
  spiSendByte(0xff);
  CS_LOW();               //!!!!!!!!!!!!!!!!!
  //Send Command 0 to put MMC in SPI mode
  mmcSendCmd(0x00,0,0x95);
  //Now wait for READY RESPONSE
  if(mmcGetResponse()!=0x01);
//       debug_printf("no responce");

  while(response==0x01)
  {
 //  debug_printf("Sending Command 1");
   CS_HIGH();               //!!!!!!!!!!!!!
   spiSendByte(0xff);
   CS_LOW();                  //!!!!!!!!!!!!!1
   mmcSendCmd(0x01,0x00,0xff);
   response=mmcGetResponse();
  }
  CS_HIGH();                //!!!!!!!!!!!
  spiSendByte(0xff);
 // debug_printf("MMC INITIALIZED AND SET TO SPI MODE PROPERLY.");
  return MMC_SUCCESS;
}

// Ti added mmc Get Responce
char mmcGetResponse(void)
{
  //Response comes 1-8bytes after command
  //the first bit will be a 0
  //followed by an error code
  //data will be 0xff until response
  int i=0;

  char response;

  while(i<=64)
  {
   response=spiSendByte(0xff);
   if(response==0x00)break;
   if(response==0x01)break;
   i++;
  }
  return response;
}

char mmcGetXXResponse(const char resp)
{
  //Response comes 1-8bytes after command
  //the first bit will be a 0
  //followed by an error code
  //data will be 0xff until response
  int i=0;

  char response;

  while(i<=500)
  {
   response=spiSendByte(0xff);
   if(response==resp)break;
   i++;
  }
  return response;
}
char mmcCheckBusy(void)
{
  //Response comes 1-8bytes after command
  //the first bit will be a 0
  //followed by an error code
  //data will be 0xff until response
  int i=0;

  char response;
  char rvalue;
  while(i<=64)
  {
   response=spiSendByte(0xff);
   response &= 0x1f;
   switch(response)
    {
     case 0x05: rvalue=MMC_SUCCESS;break;
     case 0x0b: return(MMC_CRC_ERROR);
     case 0x0d: return(MMC_WRITE_ERROR);
     default:
	      rvalue = MMC_OTHER_ERROR;
	      break;
    }
   if(rvalue==MMC_SUCCESS)break;
    i++;
  }
  i=0;
  do
  {
   response=spiSendByte(0xff);
   i++;
  }while(response==0);
  return response;
}
// The card will respond with a standard response token followed by a data
// block suffixed with a 16 bit CRC.

// Ti Modification: long int -> long ; int -> long
char mmcReadBlock(const unsigned long address, const unsigned long count)
{
  unsigned long i = 0;
  char rvalue = MMC_RESPONSE_ERROR;

  // Set the block length to read
  if (mmcSetBlockLength (count) == MMC_SUCCESS)	// block length could be set
    {
      // SS = LOW (on)
      CS_LOW ();            //!!!!!!!!!!!11
      // send read command MMC_READ_SINGLE_BLOCK=CMD17
      mmcSendCmd (17,address, 0xFF);
      // Send 8 Clock pulses of delay, check if the MMC acknowledged the read block command
      // it will do this by sending an affirmative response
      // in the R1 format (0x00 is no errors)
      if (mmcGetResponse() == 0x00)
	{
	  // now look for the data token to signify the start of
	  // the data
	  if (mmcGetXXResponse(MMC_START_DATA_BLOCK_TOKEN) == MMC_START_DATA_BLOCK_TOKEN)
	    {
	      // clock the actual data transfer and receive the bytes; spi_read automatically finds the Data Block
	      for (i = 0; i < 512; i++)
		mmc_buffer[i] = spiSendByte(0xff);	// is executed with card inserted

	      // get CRC bytes (not really needed by us, but required by MMC)
	      spiSendByte(0xff);
	      spiSendByte(0xff);
	      rvalue = MMC_SUCCESS;
	    }
	  else
	    {
	      // the data token was never received
	      rvalue = MMC_DATA_TOKEN_ERROR;	// 3
	    }
	}
      else
	{
	  // the MMC never acknowledge the read command
	  rvalue = MMC_RESPONSE_ERROR;	// 2
	}
    }
  else
    {
      rvalue = MMC_BLOCK_SET_ERROR;	// 1
    }
  CS_HIGH ();             //!!!!!!!!!!!
  spiSendByte(0xff);
  return rvalue;
}				// mmc_read_block



//---------------------------------------------------------------------
// Ti Modification: long int -> long
char mmcWriteBlock (const unsigned long address)
{
  unsigned long i = 0;
  char rvalue = MMC_RESPONSE_ERROR;	// MMC_SUCCESS;
  char c = 0x00;

  // Set the block length to read
  if (mmcSetBlockLength (512) == MMC_SUCCESS)	// block length could be set
    {
      // SS = LOW (on)
        CS_LOW ();          //!!!!!!!!!!!!!1
      // send write command
      mmcSendCmd (24,address, 0xFF);

      // check if the MMC acknowledged the write block command
      // it will do this by sending an affirmative response
      // in the R1 format (0x00 is no errors)
      if (mmcGetXXResponse(MMC_R1_RESPONSE) == MMC_R1_RESPONSE)
	{
	  spiSendByte(0xff);
	  // send the data token to signify the start of the data
	  spiSendByte(0xfe);
	  // clock the actual data transfer and transmitt the bytes
	  for (i = 0; i < 512; i++)
	    spiSendByte(mmc_buffer[i]);	// mmc_buffer[i];       Test: i & 0xff
	  // put CRC bytes (not really needed by us, but required by MMC)
	  spiSendByte(0xff);
	  spiSendByte(0xff);
	  // read the data response xxx0<status>1 : status 010: Data accected, status 101: Data
	  //   rejected due to a crc error, status 110: Data rejected due to a Write error.
          mmcCheckBusy();
	}
      else
	{
	  // the MMC never acknowledge the write command
	  rvalue = MMC_RESPONSE_ERROR;	// 2
	}
    }
  else
    {
      rvalue = MMC_BLOCK_SET_ERROR;	// 1
    }
  //give the MMC the required clocks to finish up what ever it needs to do
  //for (i = 0; i < 9; ++i)
  //spiSendByte(0xff);

  CS_HIGH ();           //!!!!!!!!!!!!!1
  // Send 8 Clock pulses of delay.
  spiSendByte(0xff);
  return rvalue;
}// mmc_write_block


//---------------------------------------------------------------------
void mmcSendCmd (const char cmd, unsigned long data, const char crc)
{
  char frame[6];
  char temp;
  int i;

  frame[0]=(cmd|0x40);
  for(i=3;i>=0;i--){
    temp=(char)(data>>(8*i));
    frame[4-i]=(temp);
  }
  frame[5]=(crc);
  for(i=0;i<6;i++)
    spiSendByte(frame[i]);
}


//--------------- set blocklength 2^n ------------------------------------------------------
// Ti Modification: long int-> long
char mmcSetBlockLength (const unsigned long blocklength)
{
  char rValue = MMC_TIMEOUT_ERROR;
  char i = 0;

  // SS = LOW (on)
   CS_LOW ();           //!!!!!!!!!!!

  // Set the block length to read
  //MMC_SET_BLOCKLEN =CMD16
  mmcSendCmd(16, blocklength, 0xFF);

  // get response from MMC - make sure that its 0x00 (R1 ok response format)
  if(mmcGetResponse()!=0x00);

  CS_HIGH ();             //!!!!!!!!!!!!!1

  // Send 8 Clock pulses of delay.
  spiSendByte(0xff);

  return MMC_SUCCESS;
}				


unsigned char spiSendByte(unsigned char data)
{
    unsigned int data_new = 0;

    data_new = data<<8;

    unsigned int spib;

    while(BSPI1_CSR2_bit.TFE == 0);      // Wait until the character can be sent
//  SSIOINT_bit.TXCMP = 1;            // clear interrupt register
    BSPI1_TXR = data_new;

//  while(SSIOINT_bit.RXCMP == 0);
    while (BSPI1_CSR2_bit.RFNE == 0);
    spib = BSPI1_RXR;                   // Get the data received
// SSIOINT_bit.RXCMP = 1;            //clear interrupt register

    spib>>=8;

    return spib;

/*
    //while(SSIOST_bit.BUSY != 0);    // Wait until the character can be sent
    SSIOINT_bit.TXCMP = 1;            //clear interrupt register
    SSIOBUF = data;                   // Send the data

    while((SSIOINT & 0x02) != 0x02);   // Wait for the transfer to complete
    spib = SSIOBUF;                   // Get the data received
    SSIOINT_bit.RXCMP = 1;            //clear interrupt register
    return spib;                      //return transmited character
*/
}


// Reading the contents of the CSD and CID registers in SPI mode is a simple
// read-block transaction.

char mmcReadRegister (const char cmd_register, const unsigned char length)
{
  char uc = 0;
  char rvalue = MMC_TIMEOUT_ERROR;
//  char i = 0;

  if (mmcSetBlockLength (length) == MMC_SUCCESS)
    {
      CS_LOW ();        //!!!!!!!!!!!11
      // CRC not used: 0xff as last byte
      mmcSendCmd(cmd_register, 0x000000, 0xff);

      // wait for response
      // in the R1 format (0x00 is no errors)
      if (mmcGetResponse() == 0x00)
	{
	 if (mmcGetXXResponse(0xfe)== 0xfe)
	    for (uc = 0; uc < length; uc++)
	      mmc_buffer[uc] = spiSendByte(0xff);
	  // get CRC bytes (not really needed by us, but required by MMC)
	  spiSendByte(0xff);
	  spiSendByte(0xff);
	}
      else
	rvalue = MMC_RESPONSE_ERROR;
      // CS = HIGH (off)
      CS_HIGH ();         //!!!!!!!!!!!!!!

      // Send 8 Clock pulses of delay.
      spiSendByte(0xff);
    }
  CS_HIGH ();             //!!!!!!!!!!!!!
  return rvalue;
}// mmc_read_register

//---------------------------------------------------------------------
#endif /* _MMCLIB_C */