mmc_drv.c

atmel at89c51snd1c mp3芯片方案源码

#include "config.h"                         /* system configuration */
#include "mmc_drv.h"                        /* mmc driver definition */


#include "lib_mcu\usb\usb_drv.h"            /* usb driver definition */
#include "lib_mcu\lcd\lcd_drv.h" 
#include "lib_mcu\clock\clock.h"
#include "modules\mem\media.h"               /* low level function definition */
#include "lib_mcu\serial\ser_drv.h"
#include <stdio.h>
#include <intrins.h>


extern         bit      bMediaWriteOpenFlag;
extern         bit      bMediaReadOpenFlag;
extern         INT16U   u16MediaBytePointer;
extern         INT32U   u32MediaSector;
extern  xdata  Byte     gl_media_buffer[512];

static  Byte    mmc_state;
static  bit     mmc_ready;                  /* MMC in prog state */
static  INT8U   u8FifoPoint;

void    mmc_set_prio (Byte);
void    mmc_send_cmd (Byte, Uint32, Byte);
bit     mmc_check_response (void);


/*****************************************************************************/
void mmc_set_prio (Byte priority)
{
  if ((priority == 1) || (priority == 3))     /* set LSB priority bit */
  {
    IPL1 |=  MSK_ESPI;
  }
  if ((priority == 2) || (priority == 3))     /* set MSB priority bit */
  {
    IPH1 |= MSK_ESPI;
  }
}



/*****************************************************************************/
void mmc_send_cmd (Byte index, Uint32 argument, Byte response)
{
  MMCMD = index;
  MMCMD = ((Byte*)&argument)[0];
  MMCMD = ((Byte*)&argument)[1];
  MMCMD = ((Byte*)&argument)[2];
  MMCMD = ((Byte*)&argument)[3];

  switch (response)
  {
    case MMC_RESP_R1:
    case MMC_RESP_R4:
    case MMC_RESP_R5:
    {
      MMCON0 |= MSK_RFMT;                   /* set 48 bits response */
      MMCON0 &= ~MSK_CRCDIS;                /* set response with CRC7 */
      MMCON1 |= (MSK_CMDEN|MSK_RESPEN);
      MMCON1 &= ~(MSK_CMDEN|MSK_RESPEN);    /* send command with response */
      break;
    }
    case MMC_RESP_R2:
    {
      MMCON0 &= ~(MSK_RFMT | MSK_CRCDIS);   /* set 136 bits response with CRC7 */
      MMCON1 |= (MSK_CMDEN|MSK_RESPEN);
      MMCON1 &= ~(MSK_CMDEN|MSK_RESPEN);    /* send command with response */
      break;
    }
    case MMC_RESP_R3:
    {
      MMCON0 |= (MSK_RFMT | MSK_CRCDIS);    /* set 48 bits response without CRC7 */
      MMCON1 |= (MSK_CMDEN|MSK_RESPEN);
      MMCON1 &= ~(MSK_CMDEN|MSK_RESPEN);    /* send command with response */
      break;
    }
    case MMC_NO_RESP:
    default:
    {
      MMCON1 |= MSK_CMDEN;
      MMCON1 &= ~MSK_CMDEN;                 /* send command without response */
      break;
    }
  }
}


/*****************************************************************************/
void mmc_send_scmd (Byte index, Byte response)
{
  MMCMD = index;
  MMCMD = (Byte)MMC_NO_ARG;
  MMCMD = (Byte)MMC_NO_ARG;
  MMCMD = (Byte)MMC_NO_ARG;
  MMCMD = (Byte)MMC_NO_ARG;

  switch (response)
  {
    case MMC_RESP_R1:
    case MMC_RESP_R4:
    case MMC_RESP_R5:
    case SD_RESP_R6:
    {
      MMCON0 |= MSK_RFMT;                   /* set 48 bits response */
      MMCON0 &= ~MSK_CRCDIS;                /* set response with CRC7 */
      MMCON1 |= (MSK_CMDEN|MSK_RESPEN);
      MMCON1 &= ~(MSK_CMDEN|MSK_RESPEN);    /* send command with response */
      break;
    }
    case MMC_RESP_R2:
    {
      MMCON0 &= ~(MSK_RFMT | MSK_CRCDIS);   /* set 136 bits response with CRC7 */
      MMCON1 |= (MSK_CMDEN|MSK_RESPEN);
      MMCON1 &= ~(MSK_CMDEN|MSK_RESPEN);    /* send command with response */
      break;
    }
    case MMC_RESP_R3:
    {
      MMCON0 |= (MSK_RFMT | MSK_CRCDIS);    /* set 48 bits response without CRC7 */
      MMCON1 |= (MSK_CMDEN|MSK_RESPEN);
      MMCON1 &= ~(MSK_CMDEN|MSK_RESPEN);    /* send command with response */
      break;
    }
    case MMC_NO_RESP:
    default:
    {
      MMCON1 |= MSK_CMDEN;
      MMCON1 &= ~MSK_CMDEN;                 /* send command without response */
      break;
    }
  }
}



/*****************************************************************************/
bit mmc_check_response (void)
{
  if (Mmc_response_received())
  { 
    /* response received */
    if ((MMCON0 & MSK_CRCDIS) != 0)
    {                                         /* CRC7 not computed */
      if ((MMSTA & MSK_RESPFS) != 0)
      {
        return (MMC_RESP_OK);
      }
      else
      {
        return (MMC_ERR_RESP);                /* format error */
      }
    }
    else
    {                                         /* CRC7 computed */
      if ((MMSTA & (MSK_RESPFS | MSK_CRC7S)) == (MSK_RESPFS | MSK_CRC7S))
      {
        return (MMC_RESP_OK);
      }
      else
      {
        return (MMC_ERR_RESP);                /* format or CRC7 error */
      }
    }
  }
  else
  { /* no response received */
    return (MMC_ERR_RESP);
  }
}



/*****************************************************************************/
Uint32 mmc_read_response (void)
{
   Uint32  argument;

  ((Byte*)&argument)[0] = MMCMD;    /* dummy index read */
  ((Byte*)&argument)[0] = MMCMD;
  ((Byte*)&argument)[1] = MMCMD;
  ((Byte*)&argument)[2] = MMCMD;
  ((Byte*)&argument)[3] = MMCMD;

  return argument;
}


//////////////////////////////////////////////////////////////////////////////
INT8U mmc_response_Try(void)
{
   INT8U i;

   for(i=0; i<100; i++)
   {
      if(mmc_check_response())
	  {
	     return OK;
	  }
   } 
   return KO;
}


//////////////////////////////////////////////////////////////////////////////
bit Mmc_init(void)
{
   INT8U ARRARY[17];

   Mmc_reset();
   Mmc_set_clock(30);                                //the clk speed must less than 400khz
   Mmc_enable();
   Mmc_disable_flow_ctrl();
   
   mmc_send_scmd(MMC_GO_IDLE_STATE, MMC_NO_RESP);    //reset
   clock_vDelay(0xfff);

   do
   {
      mmc_send_cmd(MMC_SEND_OP_COND, 0x00100000, MMC_RESP_R3);   //CMD1
      if(OK == mmc_response_Try())
      {
        ARRARY[0] = Mmc_rd_cmd();
		ARRARY[0] = Mmc_rd_cmd();
        ARRARY[1] = Mmc_rd_cmd();
        ARRARY[2] = Mmc_rd_cmd();
        ARRARY[3] = Mmc_rd_cmd();
      }
   }while(!ARRARY[0]);


   mmc_send_scmd(MMC_ALL_SEND_CID, MMC_RESP_R2);     //send cid
   if(OK == mmc_response_Try())
   {
         ;
   }

   mmc_send_cmd(MMC_SET_RELATIVE_ADDRESS, 0x0001ffff, MMC_RESP_R1);//set address
   if(OK == mmc_response_Try())
   {
      ;
   }

   mmc_send_cmd(MMC_SELECT_CARD, 0x0001ffff, MMC_RESP_R1);    //select addressed card
   if(OK == mmc_response_Try())
   {
      ;
   }

/*
   mmc_send_cmd(MMC_SEND_CSD, 0x0001ffff, MMC_RESP_R2);    //csd
   if(OK == mmc_response_Try())
   {
		ARRARY[0] = Mmc_rd_cmd();
        ARRARY[1] = Mmc_rd_cmd();
        ARRARY[2] = Mmc_rd_cmd();
        ARRARY[3] = Mmc_rd_cmd();
		ARRARY[5] = Mmc_rd_cmd();
        ARRARY[6] = Mmc_rd_cmd();

        ser_putch(ARRARY[0]);
        ser_putch(ARRARY[1]);
        ser_putch(ARRARY[2]);
        ser_putch(ARRARY[3]);
        ser_putch(ARRARY[4]);
        ser_putch(ARRARY[5]);
        ser_putch(ARRARY[6]);
        while(1);
      //printch(0,"3-Success");
   }*/

   Mmc_set_clock(1);         //speed up the clk freq
   Mmc_set_single_block();   //
   Mmc_set_block_size(9);    //512 Byte per sector

   mmc_send_cmd(MMC_SET_BLOCK_LEN, 512, MMC_RESP_R1);
   if(OK == mmc_response_Try())
   {
     ;
   }
   return OK;
}


//////////////////////////////////////////////////////////////////////////////
bit mmc_read_open(INT32U u32MmcSector)
{
  INT32U u32Address;
  INT16U i;

  u32Address = u32MmcSector;
  u32Address <<= 9;

  Mmc_read_block_cmd(u32Address);

  if(OK == mmc_response_Try())
  {   
     u32MediaSector = u32MmcSector;    //remember the sector
     u16MediaBytePointer = 0;         //point to the first byte of the sector
     bMediaReadOpenFlag = 1;

     Mmc_enable_flow_ctrl();      
     Mmc_set_read();
     Mmc_enable_send();

     while(!Mmc_read_ready());

     for(i=0; i<512;)
	 {
	    gl_media_buffer[i++] = Mmc_rd_byte();
        gl_media_buffer[i++] = Mmc_rd_byte();
	    gl_media_buffer[i++] = Mmc_rd_byte();
        gl_media_buffer[i++] = Mmc_rd_byte();